CircuitBreakerConfig.Builder (resilience4j-circuitbreaker 1.1.0 API)

java.lang.Object
- io.github.resilience4j.circuitbreaker.CircuitBreakerConfig.Builder

Enclosing class:: CircuitBreakerConfig

public static class CircuitBreakerConfig.Builder
extends java.lang.Object

Constructor Summary

Constructors
Constructor and Description

Builder()

Builder(CircuitBreakerConfig baseConfig)

Constructors
Constructor and Description
`Builder()`
`Builder(CircuitBreakerConfig baseConfig)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`CircuitBreakerConfig.Builder`	`automaticTransitionFromOpenToHalfOpenEnabled(boolean enableAutomaticTransitionFromOpenToHalfOpen)` Enables automatic transition from OPEN to HALF_OPEN state once the waitDurationInOpenState has passed.
`CircuitBreakerConfig`	`build()` Builds a CircuitBreakerConfig
`CircuitBreakerConfig.Builder`	`enableAutomaticTransitionFromOpenToHalfOpen()` Enables automatic transition from OPEN to HALF_OPEN state once the waitDurationInOpenState has passed.
`CircuitBreakerConfig.Builder`	`failureRateThreshold(float failureRateThreshold)` Configures the failure rate threshold in percentage.
`CircuitBreakerConfig.Builder`	`ignoreException(java.util.function.Predicate<java.lang.Throwable> predicate)` Configures a Predicate which evaluates if an exception should be ignored and neither count as a failure nor success.
`CircuitBreakerConfig.Builder`	`ignoreExceptions(java.lang.Class<? extends java.lang.Throwable>... errorClasses)` Configures a list of error classes that are ignored and thus neither count as a failure nor success.
`CircuitBreakerConfig.Builder`	`minimumNumberOfCalls(int minimumNumberOfCalls)` Configures configures the minimum number of calls which are required (per sliding window period) before the CircuitBreaker can calculate the error rate.
`CircuitBreakerConfig.Builder`	`permittedNumberOfCallsInHalfOpenState(int permittedNumberOfCallsInHalfOpenState)` Configures the number of permitted calls when the CircuitBreaker is half open.
`CircuitBreakerConfig.Builder`	`recordException(java.util.function.Predicate<java.lang.Throwable> predicate)` Configures a Predicate which evaluates if an exception should be recorded as a failure and thus increase the failure rate.
`CircuitBreakerConfig.Builder`	`recordExceptions(java.lang.Class<? extends java.lang.Throwable>... errorClasses)` Configures a list of error classes that are recorded as a failure and thus increase the failure rate.
`CircuitBreakerConfig.Builder`	`recordFailure(java.util.function.Predicate<java.lang.Throwable> predicate)` Deprecated. use `recordException(Predicate)` instead.
`CircuitBreakerConfig.Builder`	`ringBufferSizeInClosedState(int ringBufferSizeInClosedState)` Deprecated. Use `#slidingWindow(int, int, SlidingWindowType)` instead.
`CircuitBreakerConfig.Builder`	`ringBufferSizeInHalfOpenState(int ringBufferSizeInHalfOpenState)` Deprecated. Use `permittedNumberOfCallsInHalfOpenState(int)` instead.
`CircuitBreakerConfig.Builder`	`slidingWindow(int slidingWindowSize, int minimumNumberOfCalls, CircuitBreakerConfig.SlidingWindowType slidingWindowType)` Configures the sliding window which is used to record the outcome of calls when the CircuitBreaker is closed.
`CircuitBreakerConfig.Builder`	`slidingWindowSize(int slidingWindowSize)` Configures the size of the sliding window which is used to record the outcome of calls when the CircuitBreaker is closed.
`CircuitBreakerConfig.Builder`	`slidingWindowType(CircuitBreakerConfig.SlidingWindowType slidingWindowType)` Configures the type of the sliding window which is used to record the outcome of calls when the CircuitBreaker is closed.
`CircuitBreakerConfig.Builder`	`slowCallDurationThreshold(java.time.Duration slowCallDurationThreshold)` Configures the duration threshold above which calls are considered as slow and increase the slow calls percentage.
`CircuitBreakerConfig.Builder`	`slowCallRateThreshold(float slowCallRateThreshold)` Configures a threshold in percentage.
`CircuitBreakerConfig.Builder`	`waitDurationInOpenState(java.time.Duration waitDurationInOpenState)` Configures the wait duration which specifies how long the CircuitBreaker should stay open, before it switches to half open.
`CircuitBreakerConfig.Builder`	`writableStackTraceEnabled(boolean writableStackTraceEnabled)` Enables writable stack traces.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Builder
```
public Builder(CircuitBreakerConfig baseConfig)
```
  - Builder
```
public Builder()
```
- Method Detail
  - failureRateThreshold
```
public CircuitBreakerConfig.Builder failureRateThreshold(float failureRateThreshold)
```
    Configures the failure rate threshold in percentage. If the failure rate is equal or greater than the threshold the CircuitBreaker transitions to open and starts short-circuiting calls.
    The threshold must be greater than 0 and not greater than 100. Default value is 50 percentage.
    
    Parameters:
    
    failureRateThreshold - the failure rate threshold in percentage
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - slowCallRateThreshold
```
public CircuitBreakerConfig.Builder slowCallRateThreshold(float slowCallRateThreshold)
```
    Configures a threshold in percentage. The CircuitBreaker considers a call as slow when the call duration is greater than slowCallDurationThreshold(Duration). When the percentage of slow calls is equal or greater the threshold, the CircuitBreaker transitions to open and starts short-circuiting calls.
    The threshold must be greater than 0 and not greater than 100. Default value is 100 percentage which means that all recorded calls must be slower than slowCallDurationThreshold(Duration).
    
    Parameters:
    
    slowCallRateThreshold - the slow calls threshold in percentage
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - writableStackTraceEnabled
```
public CircuitBreakerConfig.Builder writableStackTraceEnabled(boolean writableStackTraceEnabled)
```
    Enables writable stack traces. When set to false, Throwable.getStackTrace() returns a zero length array. This may be used to reduce log spam when the circuit breaker is open as the cause of the exceptions is already known (the circuit breaker is short-circuiting calls).
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - waitDurationInOpenState
```
public CircuitBreakerConfig.Builder waitDurationInOpenState(java.time.Duration waitDurationInOpenState)
```
    Configures the wait duration which specifies how long the CircuitBreaker should stay open, before it switches to half open. Default value is 60 seconds.
    
    Parameters:
    
    waitDurationInOpenState - the wait duration which specifies how long the CircuitBreaker should stay open
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - slowCallDurationThreshold
```
public CircuitBreakerConfig.Builder slowCallDurationThreshold(java.time.Duration slowCallDurationThreshold)
```
    Configures the duration threshold above which calls are considered as slow and increase the slow calls percentage. Default value is 60 seconds.
    
    Parameters:
    
    slowCallDurationThreshold - the duration above which calls are considered as slow
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - permittedNumberOfCallsInHalfOpenState
```
public CircuitBreakerConfig.Builder permittedNumberOfCallsInHalfOpenState(int permittedNumberOfCallsInHalfOpenState)
```
    Configures the number of permitted calls when the CircuitBreaker is half open.
    The size must be greater than 0. Default size is 10.
    
    Parameters:
    
    permittedNumberOfCallsInHalfOpenState - the permitted number of calls when the CircuitBreaker is half open
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - ringBufferSizeInHalfOpenState
```
@Deprecated
public CircuitBreakerConfig.Builder ringBufferSizeInHalfOpenState(int ringBufferSizeInHalfOpenState)
```
    Deprecated. Use permittedNumberOfCallsInHalfOpenState(int) instead.
  - ringBufferSizeInClosedState
```
@Deprecated
public CircuitBreakerConfig.Builder ringBufferSizeInClosedState(int ringBufferSizeInClosedState)
```
    Deprecated. Use #slidingWindow(int, int, SlidingWindowType) instead.
  - slidingWindow
```
public CircuitBreakerConfig.Builder slidingWindow(int slidingWindowSize,
                                                  int minimumNumberOfCalls,
                                                  CircuitBreakerConfig.SlidingWindowType slidingWindowType)
```
    Configures the sliding window which is used to record the outcome of calls when the CircuitBreaker is closed. slidingWindowSize configures the size of the sliding window. Sliding window can either be count-based or time-based. minimumNumberOfCalls configures the minimum number of calls which are required (per sliding window period) before the CircuitBreaker can calculate the error rate. For example, if minimumNumberOfCalls is 10, then at least 10 calls must be recorded, before the failure rate can be calculated. If only 9 calls have been recorded the CircuitBreaker will not transition to open even if all 9 calls have failed. If slidingWindowSize is 100 and slidingWindowType is COUNT_BASED, the last 100 calls are recorded and aggregated. If slidingWindowSize is 10 and slidingWindowType is TIME_BASED, the calls of the last 10 seconds are recorded and aggregated.
    The slidingWindowSize must be greater than 0. The minimumNumberOfCalls must be greater than 0. If the slidingWindowType is COUNT_BASED, the minimumNumberOfCalls cannot be greater than slidingWindowSize. If the slidingWindowType is TIME_BASED, you can pick whatever you want. Default slidingWindowSize is 100, minimumNumberOfCalls is 100 and slidingWindowType is COUNT_BASED.
    
    Parameters:
    
    slidingWindowSize - the size of the sliding window when the CircuitBreaker is closed.
    
    minimumNumberOfCalls - the minimum number of calls that must be recorded before the failure rate can be calculated.
    
    slidingWindowType - the type of the sliding window. Either COUNT_BASED or TIME_BASED.
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - slidingWindowSize
```
public CircuitBreakerConfig.Builder slidingWindowSize(int slidingWindowSize)
```
    Configures the size of the sliding window which is used to record the outcome of calls when the CircuitBreaker is closed. slidingWindowSize configures the size of the sliding window. Sliding window can either be count-based or time-based. If slidingWindowType is COUNT_BASED, the last slidingWindowSize calls are recorded and aggregated. If slidingWindowType is TIME_BASED, the calls of the last slidingWindowSize seconds are recorded and aggregated.
    The slidingWindowSize must be greater than 0. The minimumNumberOfCalls must be greater than 0. If the slidingWindowType is COUNT_BASED, the minimumNumberOfCalls cannot be greater than slidingWindowSize. If the slidingWindowType is TIME_BASED, you can pick whatever you want. Default slidingWindowSize is 100.
    
    Parameters:
    
    slidingWindowSize - the size of the sliding window when the CircuitBreaker is closed.
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - minimumNumberOfCalls
```
public CircuitBreakerConfig.Builder minimumNumberOfCalls(int minimumNumberOfCalls)
```
    Configures configures the minimum number of calls which are required (per sliding window period) before the CircuitBreaker can calculate the error rate. For example, if minimumNumberOfCalls is 10, then at least 10 calls must be recorded, before the failure rate can be calculated. If only 9 calls have been recorded the CircuitBreaker will not transition to open even if all 9 calls have failed. Default minimumNumberOfCalls is 100
    
    Parameters:
    
    minimumNumberOfCalls - the minimum number of calls that must be recorded before the failure rate can be calculated.
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - slidingWindowType
```
public CircuitBreakerConfig.Builder slidingWindowType(CircuitBreakerConfig.SlidingWindowType slidingWindowType)
```
    Configures the type of the sliding window which is used to record the outcome of calls when the CircuitBreaker is closed. Sliding window can either be count-based or time-based. If slidingWindowType is COUNT_BASED, the last slidingWindowSize calls are recorded and aggregated. If slidingWindowType is TIME_BASED, the calls of the last slidingWindowSize seconds are recorded and aggregated. Default slidingWindowType is COUNT_BASED.
    
    Parameters:
    
    slidingWindowType - the type of the sliding window. Either COUNT_BASED or TIME_BASED.
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - recordFailure
```
@Deprecated
public CircuitBreakerConfig.Builder recordFailure(java.util.function.Predicate<java.lang.Throwable> predicate)
```
    Deprecated. use recordException(Predicate) instead.
  - recordException
```
public CircuitBreakerConfig.Builder recordException(java.util.function.Predicate<java.lang.Throwable> predicate)
```
    Configures a Predicate which evaluates if an exception should be recorded as a failure and thus increase the failure rate. The Predicate must return true if the exception should count as a failure. The Predicate must return false, if the exception should count as a success, unless the exception is explicitly ignored by ignoreExceptions(Class[]) or ignoreException(Predicate).
    
    Parameters:
    
    predicate - the Predicate which evaluates if an exception should count as a failure
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - ignoreException
```
public CircuitBreakerConfig.Builder ignoreException(java.util.function.Predicate<java.lang.Throwable> predicate)
```
    Configures a Predicate which evaluates if an exception should be ignored and neither count as a failure nor success. The Predicate must return true if the exception should be ignored . The Predicate must return false, if the exception should count as a failure.
    
    Parameters:
    
    predicate - the Predicate which evaluates if an exception should count as a failure
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - recordExceptions
```
@SafeVarargs
public final CircuitBreakerConfig.Builder recordExceptions(@Nullable
                                                                         java.lang.Class<? extends java.lang.Throwable>... errorClasses)
```
    Configures a list of error classes that are recorded as a failure and thus increase the failure rate. Any exception matching or inheriting from one of the list should count as a failure, unless ignored via
    
    Parameters:
    
    errorClasses - the error classes that are recorded
    
    Returns:
    
    the CircuitBreakerConfig.Builder
    
    See Also:
    
    ). Ignoring an exception has priority over recording an exception. Example: recordExceptions(Throwable.class) and ignoreExceptions(RuntimeException.class) would capture all Errors and checked Exceptions, and ignore RuntimeExceptions.
    For a more sophisticated exception management use the, method
  - ignoreExceptions
```
@SafeVarargs
public final CircuitBreakerConfig.Builder ignoreExceptions(@Nullable
                                                                         java.lang.Class<? extends java.lang.Throwable>... errorClasses)
```
    Configures a list of error classes that are ignored and thus neither count as a failure nor success. Any exception matching or inheriting from one of the list will not count as a failure nor success, even if marked via
    
    Parameters:
    
    errorClasses - the error classes that are ignored
    
    Returns:
    
    the CircuitBreakerConfig.Builder
    
    See Also:
    
    . Ignoring an exception has priority over recording an exception. Example: ignoreExceptions(Throwable.class) and recordExceptions(Exception.class) would capture nothing. Example: ignoreExceptions(Exception.class) and recordExceptions(Throwable.class) would capture Errors.
    For a more sophisticated exception management use the, method
  - enableAutomaticTransitionFromOpenToHalfOpen
```
public CircuitBreakerConfig.Builder enableAutomaticTransitionFromOpenToHalfOpen()
```
    Enables automatic transition from OPEN to HALF_OPEN state once the waitDurationInOpenState has passed.
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - automaticTransitionFromOpenToHalfOpenEnabled
```
public CircuitBreakerConfig.Builder automaticTransitionFromOpenToHalfOpenEnabled(boolean enableAutomaticTransitionFromOpenToHalfOpen)
```
    Enables automatic transition from OPEN to HALF_OPEN state once the waitDurationInOpenState has passed.
    
    Returns:
    
    the CircuitBreakerConfig.Builder
  - build
```
public CircuitBreakerConfig build()
```
    Builds a CircuitBreakerConfig
    
    Returns:
    
    the CircuitBreakerConfig

Class CircuitBreakerConfig.Builder

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Builder

Builder

Method Detail

failureRateThreshold

slowCallRateThreshold

writableStackTraceEnabled

waitDurationInOpenState

slowCallDurationThreshold

permittedNumberOfCallsInHalfOpenState

ringBufferSizeInHalfOpenState

ringBufferSizeInClosedState

slidingWindow

slidingWindowSize

minimumNumberOfCalls

slidingWindowType

recordFailure

recordException

ignoreException

recordExceptions

ignoreExceptions

enableAutomaticTransitionFromOpenToHalfOpen

automaticTransitionFromOpenToHalfOpenEnabled

build