/** Returns a {@link String} representation of the breaker's * status; potentially useful for exposing to monitoring software. * @return <code>String</code> which is <code>"GREEN"</code> if * the breaker is CLOSED; <code>"YELLOW"</code> if the breaker * is HALF_CLOSED; and <code>"RED"</code> if the breaker is * OPEN (tripped). */ public String getHealthCheck() { return getStatus().getSignal(); }
/** * Default constructor. Any {@link Throwable} will cause the breaker to trip. */ @SuppressWarnings("unchecked") public PercentErrPerTimeFailureInterpreter() { setIgnore(defaultIgnore); requestCounter = new RequestCounter(); }
private void recordRequest() { double[] rates = flowMeter.sample(); totalRequestsPerSecondLastMinute.update(rates[0]); totalRequestsPerSecondLastHour.update(rates[0]); totalRequestsPerSecondLastDay.update(rates[0]); successRequestsPerSecondLastMinute.update(rates[1]); successRequestsPerSecondLastHour.update(rates[1]); successRequestsPerSecondLastDay.update(rates[1]); failureRequestsPerSecondLastMinute.update(rates[2]); failureRequestsPerSecondLastHour.update(rates[2]); failureRequestsPerSecondLastDay.update(rates[2]); }
public ServiceRetrier(int delay, int maxTries, boolean doubleDelay, boolean throwCauseException, Class<? extends Throwable>[] retryOn) { setDelay(delay); setMaxTries(maxTries); setDoubleDelay(doubleDelay); setThrowCauseException(throwCauseException); setRetryOn(retryOn); }
private void recordFailure(LatencyTracker latencyTracker) { long failureMillis = latencyTracker.getLastFailureMillis(); averageFailureLatencyLastMinute.update(failureMillis); averageFailureLatencyLastHour.update(failureMillis); averageFailureLatencyLastDay.update(failureMillis); lifetimeFailureLatencyQuantile.addSample(failureMillis); failureLatencyQuantileLastMinute.addSample(failureMillis); failureLatencyQuantileLastHour.addSample(failureMillis); failureLatencyQuantileLastDay.addSample(failureMillis); lifetimeMaxFailureMillis = (failureMillis > lifetimeMaxFailureMillis) ? failureMillis : lifetimeMaxFailureMillis; recordRequest(); }
private void recordSuccess(LatencyTracker latencyTracker) { long successMillis = latencyTracker.getLastSuccessMillis(); averageSuccessLatencyLastMinute.update(successMillis); averageSuccessLatencyLastHour.update(successMillis); averageSuccessLatencyLastDay.update(successMillis); lifetimeSuccessLatencyQuantile.addSample(successMillis); successLatencyQuantileLastMinute.addSample(successMillis); successLatencyQuantileLastHour.addSample(successMillis); successLatencyQuantileLastDay.addSample(successMillis); lifetimeMaxSuccessMillis = (successMillis > lifetimeMaxSuccessMillis) ? successMillis : lifetimeMaxSuccessMillis; recordRequest(); }
public <T> T invoke(Runnable r, T result) throws Exception { Callable<T> adapter = new CallableAdapter<T>(r, result); return invoke(adapter); }
/** * Returns the current {@link org.fishwife.jrugged.Status} of the * {@link CircuitBreaker}. In this case, it really refers to the * status of the client service. If the * <code>CircuitBreaker</code> is CLOSED, we report that the * client is UP; if it is HALF_CLOSED, we report that the client * is DEGRADED; if it is OPEN, we report the client is DOWN. * * @return Status the current status of the breaker */ public Status getStatus() { return getServiceStatus().getStatus(); }
/** * Reports a successful service call to the {@link CircuitBreaker}, * putting the <code>CircuitBreaker</code> back into the CLOSED * state serving requests. */ protected void close() { state = BreakerState.CLOSED; isAttemptLive = false; notifyBreakerStateChange(getStatus()); }
/** Returns the 99th-percentile latency seen by this * {@link PerformanceMonitor} for successful requests. * @return latency in milliseconds */ public long get99thPercentileSuccessLatencyLifetime() { return lifetimeSuccessLatencyQuantile.getPercentile(99); }
/** * Returns the average request rate in requests per second of * all requests, as measured over the last minute. * @return double */ public double getTotalRequestsPerSecondLastMinute() { return totalRequestsPerSecondLastMinute.getAverage(); }
public ConstantFlowRegulator(int requestsPerSecond, ConstantFlowRegulatorExceptionMapper<? extends Exception> mapper) { requestPerSecondThreshold = requestsPerSecond; calculateDeltaWaitTime(); exceptionMapper = mapper; }
/** * Specifies the length of the tolerance window in milliseconds. * @param windowMillis <code>long</code> */ public void setWindowMillis(long windowMillis) { this.windowMillis=windowMillis; initCounter(); } }
public void invoke(Runnable r) throws Exception { Callable<Void> adapter = new CallableAdapter<Void>(r); invoke(adapter); }
/** Returns the 95th-percentile latency seen by this {@link * PerformanceMonitor} for failed requests. * @return latency in milliseconds */ public long get95thPercentileFailureLatencyLifetime() { return lifetimeFailureLatencyQuantile.getPercentile(95); }
/** * Returns the average request rate in requests per second of * all requests, as measured over the last hour. * @return double */ public double getTotalRequestsPerSecondLastHour() { return totalRequestsPerSecondLastHour.getAverage(); }
/** Returns the 99th-percentile latency seen by this {@link * PerformanceMonitor} for failed requests over the last * minute. * @return latency in milliseconds */ public long get99thPercentileFailureLatencyLastMinute() { return failureLatencyQuantileLastMinute.getPercentile(99); }
/** * Returns the average request rate in requests per second of * successful requests, as measured over the last day. * @return double */ public double getSuccessRequestsPerSecondLastDay() { return successRequestsPerSecondLastDay.getAverage(); }
/** Returns the median latency seen by this {@link * PerformanceMonitor} for failed requests over the * last hour. * @return latency in milliseconds */ public long getMedianPercentileFailureLatencyLastHour() { return failureLatencyQuantileLastHour.getPercentile(50); }
/** Returns the median latency seen by this {@link * PerformanceMonitor} for failed requests over the * last day. * @return latency in milliseconds */ public long getMedianPercentileFailureLatencyLastDay() { return failureLatencyQuantileLastDay.getPercentile(50); }