Resilience4j

The Circuit Breaker pattern prevents an application from repeatedly calling a failing external service. It monitors calls and, when a configurable failure threshold is exceeded, transitions from a CLOSED to an OPEN state, failing fast for a defined duration. After this, it enters a HALF-OPEN state to test if the dependency has recovered.

• Configurable States: CLOSED (normal operation), OPEN (failing fast), HALF-OPEN (testing recovery).
• Key Metrics: Failure rate, slow call rate, and request count are tracked within a sliding window (count-based or time-based).
• Dynamic Configuration: Supports changing parameters like failureRateThreshold and waitDurationInOpenState at runtime.

The Rate Limiter pattern restricts the number of executions permitted within a specific time period, protecting a service from being overwhelmed by excessive requests. It implements a semaphore-based or token-bucket algorithm to control the flow of calls.

• Semaphore Implementation: Uses a bounded semaphore to limit concurrent executions.
• Configurable Limits: Set maximum number of permits and refresh period.
• Blocking vs. Non-Blocking: Can wait for a permit (blocking) or fail immediately if none are available.

The Bulkhead pattern isolates parts of a system to limit concurrent executions and prevent a failure in one component from consuming all resources and causing cascading failures. Resilience4j provides two implementations.

• Semaphore Bulkhead: Limits the number of concurrent calls to a specific service using a semaphore.
• ThreadPool Bulkhead: Isolates calls in a separate, bounded thread pool with a work queue.
• Isolation Benefits: A failure in a bulkheaded component exhausts only its own pool of resources, leaving the rest of the application functional.

The Retry pattern enables an application to handle transient faults by automatically reattempting a failed operation. It is configurable with various strategies to avoid exacerbating the problem for the failing service.

• Backoff Strategies: Supports fixed interval, randomized interval, and exponential backoff between attempts.
• Result & Exception Predicates: Define which results or exceptions should trigger a retry.
• Jitter: Can add randomness to backoff intervals to prevent thundering herd problems where many clients retry simultaneously.

The Time Limiter pattern sets a maximum duration for the execution of a future, preventing calls from hanging indefinitely and consuming system resources. It is typically used to wrap potentially long-running operations.

• Future-Based: Wraps a Future or CompletableFuture with a timeout.
• Scheduled Executor: Uses a ScheduledExecutorService to enforce the timeout.
• Fallback on Timeout: Can be combined with a fallback method to provide a default response when the timeout is exceeded.

Resilience4j is designed for functional programming and seamless integration with Java 8's functional interfaces and reactive streams. It supports both imperative and declarative usage styles.

• Decorator Functions: Core patterns are implemented as decorator functions (e.g., CircuitBreaker.decorateFunction()).
• Annotation Support: Provides Spring Boot annotations like @CircuitBreaker, @RateLimiter, and @Retry for declarative application.
• Reactive Support: Fully compatible with Project Reactor and RxJava for composing resilient reactive pipelines.
• Lightweight Core: Has zero dependencies outside of Vavr (functional library for Java), making it modular and easy to embed.

The most prevalent integration, facilitated by the resilience4j-spring-boot2 module. It provides:

• Auto-configuration via application.yml or application.properties.
• Declarative annotations (@CircuitBreaker, @Retry, @RateLimiter, @Bulkhead) for applying resilience patterns to methods.
• Actuator endpoints (/actuator/circuitbreakers) for monitoring health and metrics.
• Seamless integration with Spring's RestTemplate, WebClient, and Feign clients for HTTP calls.

For non-blocking, reactive systems, the resilience4j-reactor module provides decorators for Project Reactor's Mono and Flux types.

• Key Decorators: CircuitBreakerOperator.of(circuitBreaker), RateLimiterOperator.of(rateLimiter).
• Usage: Operators are applied via the .transformDeferred method, ensuring resilience logic is applied per-subscription.
• Benefits: Maintains the reactive contract, prevents blocking, and allows resilience patterns to work within the reactive stream.

Operational visibility is provided via the resilience4j-micrometer module. It publishes detailed metrics for all core components to monitoring systems.

• Exported Metrics: Circuit breaker state, failure rate, slow call rate, call counts, retry statistics, rate limiter permissions, bulkhead queue depth.
• Integration: Automatically ties into Spring Boot Actuator and can publish to Prometheus, Datadog, New Relic, etc.
• Purpose: Enables alerting on open circuit breakers, tracking error budgets, and visualizing system resilience.