Circuitbreaker fuse of resilience4j -- Measurement of circuitbreakermetrics index

Mentioned in the last article ,onError() or onSuccess() I will calculate the error rate and other indicators , Specifically by CircuitBreakerMetrics Realization

One ：CircuitBreaker.Metrics Indicator measurement interface

This interface defines a series of methods to obtain metrics , These include the following ：

// Metrics interface , Used to observe various indexes of fuse 
    interface Metrics {

        //  Returns the failure rate percentage , If the number of calls is less than MINIMUM_NUMBER_OF_CALLS, return -1
        float getFailureRate();

        // Returns the percentage of slow calls , If the number of calls is less than MINIMUM_NUMBER_OF_CALLS, return -1
        float getSlowCallRate();

       // Total slow call requests 
        int getNumberOfSlowCalls();

        // Total number of successful slow calls 
        int getNumberOfSlowSuccessfulCalls();

       // Total slow call failures 
       int getNumberOfSlowFailedCalls();
		
		// The maximum number of calls to the ring buffer 
        int getNumberOfBufferedCalls();

        //  Total number of failed calls 
        int getNumberOfFailedCalls();

        //  In the open state , Returns the number of currently disallowed request calls , In the closed and semi open states , Always return to 0
         long getNumberOfNotPermittedCalls();

        // Total number of successful calls 
        int getNumberOfSuccessfulCalls();
    }

Two ：CircuitBreakerMetrics class

yes CircuitBreaker.Metrics Implementation class of interface , The specific content is to realize CircuitBreaker.Metrics Method of definition

    // Slow call rate 
    private float getSlowCallRate(Snapshot snapshot) {
        int bufferedCalls = snapshot.getTotalNumberOfCalls();
        if (bufferedCalls == 0 || bufferedCalls < minimumNumberOfCalls) {
            return -1.0f;
        }
        return snapshot.getSlowCallRate();
    }

    // Failure rate 
    private float getFailureRate(Snapshot snapshot) {
        // Total number of calls 
        int bufferedCalls = snapshot.getTotalNumberOfCalls();
        if (bufferedCalls == 0 || bufferedCalls < minimumNumberOfCalls) {
            //ringBitSet The number of middle is not up to ringBufferSize size , return -1.0f, Failure rate is not calculated 
            return -1.0f;
        }
        // Return failure rate ：totalNumberOfFailedCalls * 100.0f / totalNumberOfCalls
        return snapshot.getFailureRate();
    }

onError() and onSuccess() The method is the state machine mentioned in the previous article CircuitBreakerStateMachine In the state class of onError() and onSuccess() Method called , Check if the error rate threshold has been reached checkIfThresholdsExceeded() Then call the state transition method of the state machine stateTransition()

 /**
     * Records a successful call and checks if the thresholds are exceeded.
     *  Check whether it is a slow call when the call is successful , If it is a slow call , Publish the slow call event first , Then count the slow call rate 
     * @return the result of the check
     */
    public Result onSuccess(long duration, TimeUnit durationUnit) {
        Snapshot snapshot;
        if (durationUnit.toNanos(duration) > slowCallDurationThresholdInNanos) {
            snapshot = metrics.record(duration, durationUnit, Outcome.SLOW_SUCCESS);
        } else {
            snapshot = metrics.record(duration, durationUnit, Outcome.SUCCESS);
        }
        return checkIfThresholdsExceeded(snapshot);
    }

    /**
     *  This method is called when it fails , Slow release / Error events , And check whether the threshold is reached 
     * 1. Record the request first , That is, the total number of requests , Error request times, etc +1
     * 2.  Calculate the failure rate / Slow call rate , Whether the threshold is reached 
     */
    public Result onError(long duration, TimeUnit durationUnit) {
        Snapshot snapshot;
        if (durationUnit.toNanos(duration) > slowCallDurationThresholdInNanos) {
            // Slow call , call Core.Metrics  Record the number of requests 
            snapshot = metrics.record(duration, durationUnit, Outcome.SLOW_ERROR);
        } else {
            // Error call , call Core.Metrics  Record the number of requests 
            snapshot = metrics.record(duration, durationUnit, Outcome.ERROR);
        }
        return checkIfThresholdsExceeded(snapshot);
    }
    
    //  Check the error rate / Whether the slow call rate reaches the threshold 
    private Result checkIfThresholdsExceeded(Snapshot snapshot) {
        // Get the failure rate 
        float failureRateInPercentage = getFailureRate(snapshot);
        if (failureRateInPercentage == -1) {
            // Less than buffer size , The check threshold has not been reached 
            return Result.BELOW_MINIMUM_CALLS_THRESHOLD;
        }
        if (failureRateInPercentage >= failureRateThreshold) {
            // Threshold exceeded 
            return Result.ABOVE_THRESHOLDS;
        }

        // Slow call rate 
        float slowCallsInPercentage = getSlowCallRate(snapshot);
        if (slowCallsInPercentage >= slowCallRateThreshold) {
            return Result.ABOVE_THRESHOLDS;
        }
        return Result.BELOW_THRESHOLDS;
    }

It also defines enumeration values to check whether the threshold is reached ：

    enum Result {
        BELOW_THRESHOLDS,
        ABOVE_THRESHOLDS,
        BELOW_MINIMUM_CALLS_THRESHOLD
    }

summary

CircuitBreakerMetrics It is mainly used to calculate various indicators of measurement