failsafe-lib/failsafe
Failsafe
Failsafe is a JVM fault tolerance library and resilience pattern framework. It provides a toolkit for implementing circuit breakers, rate limiters, and other stability patterns within Java Virtual Machine applications to prevent cascading failures in distributed systems.
The project is distinguished by its policy-based execution pipeline, which allows for the composition of multiple resilience patterns into a sequential flow. It features a state-machine circuit breaker to manage service recovery and a leaky-bucket rate limiter to control operation frequency.
The library covers a broad range of capability areas, including resource isolation through bulkheads, automated retry logic with fallback provisioning, and execution timeouts. It also provides mechanisms for asynchronous task execution and the management of non-blocking pipelines via completion stages.
Monitoring and observability are integrated through event listeners and metrics exports that track circuit state transitions and execution milestones.
Features
- Resilience Policy Pipelines - Provides a sequential pipeline of configurable policies to manage retries, timeouts, and circuit breaking.
- JVM Implementations - Provides a comprehensive fault tolerance library specifically for JVM applications.
- JVM Fault Tolerance Libraries - Provides a comprehensive toolkit for implementing resilience patterns like retries and circuit breakers within JVM applications.
- API Resilience - Implements fault tolerance policies to ensure the reliability of asynchronous API communications during service disruptions.
- Configurable Retry Engines - Repeats failed operations using a configurable engine with maximum attempts, delays, and jitter.
- Execution Rate Limiters - Controls the frequency and concurrency of operations to prevent system overload and comply with downstream limits.
- Execution Timeout Management - Implements execution timeouts to forcefully terminate operations that exceed a defined duration.
- Leaky Bucket Implementations - Implements a leaky-bucket rate limiter to control operation frequency and prevent system overload.
- Asynchronous Task Execution - Executes tasks in the background using resilience policies to prevent the main execution thread from blocking.
- Asynchronous Execution Managers - Provides a toolkit for handling non-blocking asynchronous pipelines and completion stages with integrated resilience policies.
- Cascading Failure Preventions - Provides bulkheads and rate limiting to prevent a failure in one service from triggering a domino effect across distributed systems.
- Concurrent Call Limits - Limits concurrent calls to specific components via bulkheads to prevent failures from cascading across the system.
- Circuit Breakers - Stops execution of calls to an unhealthy service after a failure threshold is met to allow for recovery.
- Concurrent Execution Limiters - Limits the number of simultaneous active calls to prevent resource exhaustion.
- Fault-Tolerant Fallbacks - Returns default values or computes alternative results when a primary execution fails to complete successfully.
- Fault Tolerance Implementation - Implements a toolkit of resilience patterns to ensure system continuity during remote service outages.
- Rate Limiters - Implements application-level rate limiting using token bucket and fixed window algorithms.
- Bulkheading - Provides bulkheading to limit concurrent calls and prevent single-service failures from exhausting system resources.
- Resilience Patterns - Provides a framework for applying resilience patterns like circuit breakers, timeouts, and bulkheads.
- Circuit Breaking States - Implements a state-machine circuit breaker that transitions between open, closed, and half-open states.
- Event Listeners - Offers programmatic hooks to trigger actions upon task completion, failure, or execution cycles.
- Policy-Wrapped Stages - Wraps completion stage suppliers to apply fault tolerance policies to asynchronous pipelines.
- Exception Filters - Specifies which exceptions or business result conditions trigger a resilience policy instead of using global defaults.
- Future Policy Wrapping - Wraps completion stages and futures to apply fault tolerance policies across non-blocking execution flows.
- Reactive Client Integrations - Integrates fault tolerance policies into non-blocking, reactive communication flows for asynchronous APIs.
- Asynchronous Task Cancellation - Interrupts running asynchronous operations by checking cancellation flags or interrupting threads to prevent wasted resources.
- Manual State Overrides - Allows forcing the circuit breaker into open or closed states independently of automatic policy triggers.
- Event-Driven Hook Systems - Triggers registered listeners during policy state transitions and execution milestones for real-time health visibility.
- Fault Tolerance Policies - Manages execution state by recording results to determine if an operation requires a retry based on policies.
- Custom Resilience Policies - Enables the creation of specialized fault tolerance behaviors through custom policy and executor implementations.
- Request Timeout Management - Enforces maximum durations for remote network operations to prevent indefinite blocking and resource exhaustion.
- Reusable Policy Configurations - Resilience4j saves specific combinations of resilience policies to apply them consistently across different parts of an application.
- Asynchronous Schedulers - Defines thread pools and custom schedulers to manage the timing and execution of asynchronous tasks.
- Metrics Exporters - Exposes a monitoring interface to export performance and state metrics for fault tolerance policies.
- Retry Metrics Monitoring - Provides telemetry and notifications for retry attempt failures and scheduling events.
