All Classes and Interfaces
Class
Description
Bulkhead pattern: bound how many calls may execute concurrently, isolating the protected
resource from overload.
Counter/timer-worthy occurrences emitted by a Bulkhead.
Events emitted by the Bulkhead pattern.
Thrown when a Bulkhead rejects a call because all permits are in use and no permit
became available within the configured maximum wait time.
Gauge-worthy live state of a Bulkhead.
A
ResilienceEvent.Listener that records every event it receives, in arrival order,
for assertion in tests.CircuitBreaker pattern: track recent call outcomes in a sliding window and stop calling a
failing or slow downstream once the failure or slow-call rate crosses its threshold,
rejecting calls immediately instead of piling more load onto something already struggling.
Counter/timer-worthy occurrences emitted by a CircuitBreaker.
Emitted alongside a Transition(to=CLOSED): every Closed transition originates from HalfOpen
in the current state machine, and successfulTestCalls only has meaning for that specific
case.
A call rejected without executing, because the circuit was Open or HalfOpen with no permits
left.
Events emitted by the CircuitBreaker pattern.
Thrown when a call is rejected because the circuit breaker will not let it through: either
the circuit is Open, or it is HalfOpen and every permitted test call has already been issued.
Gauge-worthy live state of a CircuitBreaker.
Deliberately a small, stable enum, not a reuse of
patterns' own CircuitState
sealed type — CircuitState.Open carries fields useful to the pattern but irrelevant
and unstable as gauge content.The state of a
CircuitBreaker at a point in time.Calls pass through normally while their outcomes are recorded in the sliding window.
A limited number of test calls are let through to probe whether the downstream has
recovered.
Calls are rejected immediately.
Abstraction over time, used by patterns that need to read the current instant or wait
(Retry backoff, CircuitBreaker open-state duration, RateLimiter windows, ...).
Counter/timer-worthy occurrences emitted by a pattern or by Policy's order validation.
How
OpenTelemetryResilienceMetrics records duration metrics
(resilience.timeout.duration, resilience.circuitbreaker.calls).Fake implementation of
ResilienceMetrics for testing code that consumes metrics.A pass-through
Resilient for testing code that composes or accepts patterns
(e.g.Thrown when a Policy is constructed with an invalid configuration (e.g. no patterns).
Deterministic
Clock for tests: time only moves when advanced explicitly via
ManualClock.advance(java.time.Duration) or when a pattern sleeps, so timing-based behavior (Retry backoff,
RateLimiter windows) can be asserted exactly and runs instantly.ResilienceMetrics backed by a Micrometer MeterRegistry.A no-op
ResilienceMetrics implementation that discards all recordings.ResilienceMetrics backed by an OpenTelemetry Meter.Result of executing an operation with a pattern.
Operation failed with an exception.
Operation succeeded and returned a value.
Operation did not complete within the configured timeout.
AssertJ assertions for
Outcome.The kind of a resilience pattern, used for internal identity checks — e.g.
Fluent composition of multiple resilience patterns.
Counter-worthy occurrences emitted by Policy's order validation.
Emitted by
Policy whenever a WARN-severity OrderingRule fires during
Policy.and(Resilient) and construction proceeds — in addition to, not instead of, the
existing SLF4J WARN log line.RateLimiter pattern: bound how many calls may start per time window (fixed window,
limit calls per period).Counter/timer-worthy occurrences emitted by a RateLimiter.
Events emitted by the RateLimiter pattern.
Thrown when a RateLimiter rejects a call because the current window's permits are used up
and no permit would become available within the configured maximum wait time.
Gauge-worthy live state of a RateLimiter.
Base interface for all resilience events.
Listener for consuming events from patterns.
Backend-facing contract that concrete metrics implementations (Micrometer, OpenTelemetry, custom)
must implement to observe pattern and Policy events as metrics.
Entry point for resiliencia-specific AssertJ assertions.
Base interface for all resilience patterns.
Base exception for all resiliencia errors.
Thrown when an operation does not complete within the configured timeout.
Retry pattern: execute an operation, retrying on failure up to maxAttempts.
Counter/timer-worthy occurrences emitted by Retry.
One failed attempt, sourced from
RetryEvent.AttemptFailed, which fires once per
failed attempt within a call.The call succeeded — sourced from
RetryEvent.Success, emitted exactly once per call,
when the retry loop as a whole succeeds.Events emitted by the Retry pattern.
Thrown by the Retry pattern when all configured attempts have failed.
Thrown by the Retry pattern when the thread is interrupted while waiting for a backoff delay
between attempts.
Thrown by the Retry pattern when
shouldRetry declines to retry a failure before the
attempt budget is exhausted.Gauge-worthy live state emitted by a pattern.
Timeout pattern: execute an operation on a virtual thread and bound how long the caller
waits for it.
Counter/timer-worthy occurrences emitted by Timeout.
Events emitted by the Timeout pattern.
The abandoned worker (interrupted or left running past the timeout) eventually failed.
The abandoned worker (interrupted or left running past the timeout) eventually succeeded.