All Classes and Interfaces
Class
Description
Base
FailoverExpiryExtractor that resolves expiry configuration from a @Failover
annotation, preferring SpEL expression attributes over the literal numeric ones.Base
ObservablePublisher that delegates publishing to AbstractObservablePublisher.doPublish(com.societegenerale.failover.core.observable.Metrics).FailoverHandler decorator that publishes metrics on every store/recover operation
and delegates payload post-processing to a RecoveredPayloadHandler.Basic
FailoverExecution that invokes the supplier, stores the result on success,
and attempts recovery via the FailoverHandler on any exception.AbstractFailoverExpiryExtractor that interprets expression strings as plain literals:
durations are parsed with Long.parseLong(java.lang.String, int) and units with ChronoUnit.valueOf(java.lang.String).Spring
BeanFactory-backed implementation of ExpiryPolicyLookup.AbstractFailoverExpiryExtractor that resolves expiry expressions via
Spring's ConfigurableBeanFactory.resolveEmbeddedValue(java.lang.String), supporting
property placeholders (e.g.Spring
BeanFactory-backed implementation of KeyGeneratorLookup.Spring
BeanFactory-backed implementation of PayloadSplitterLookup.ManifestInfoExtractor decorator that caches extraction results by artifact title
to avoid repeated classpath scans.Utility for unchecked generic casts needed to bridge raw types at framework boundaries.
ResourceLoader that resolves resources via the current thread's class loader.ContextPropagator that chains multiple propagators, applying each in order.ObservablePublisher that stamps the publish timestamp once and fans metrics out
to a list of delegate publishers.Strategy for propagating thread-bound context (tenant ID, security principal, MDC trace)
across executor boundaries in scatter/gather operations.
Strategy for detecting the underlying database product name from a live JDBC connection.
Default
DatabaseResolver that reads the database product name from JDBC connection metadata.Default
ExpiryPolicy that computes expiry by adding the annotation-configured duration
to the current clock time, and checks expiry against the current clock.Default
FailoverClock that returns the current UTC instant from the system clock.Default
FailoverHandler that persists payloads to the failover store on success
and retrieves them on failure, applying expiry checks and payload enrichment.Default
FailoverObserver that scans for all @Failover-annotated methods
and publishes a startup summary metric for each one.Default
FailoverStore decorator that ensures every payload written to or read from
the delegate store has its upToDate flag forced to false.Default
FailoverStoreQueryResolver that resolves all JDBC queries against a given table
prefix, selects the appropriate native merge/upsert dialect for the detected database, and owns
all parameter binding and result-set mapping logic.Default
KeyGenerator that derives a cache key from method arguments.ManifestInfoExtractor that searches all META-INF/MANIFEST.MF resources on
the classpath for an entry whose Implementation-Title matches the requested title.Default
PayloadEnricher that propagates failover metadata (upToDate, asOf,
exception info) into payloads that implement Referential
or ReferentialAware.Strategy that governs how the failover framework handles exceptions thrown by
the primary method when recovery is unavailable or the stored entry has expired.
Wraps a
Throwable thrown during the actual method execution inside the failover aspect.Spring scheduler that periodically removes expired entries from the failover store via
FailoverHandler.clean().Strategy for computing and checking expiry of stored failover payloads.
Strategy for resolving an
ExpiryPolicy by qualifier or bean name.Thrown when no
ExpiryPolicy bean is found for the qualifier specified in a @Failover annotation.Annotation for handling the failover of the invoking a method.
AspectJ around-advice that intercepts methods annotated with
Failover and delegates
execution to the configured FailoverExecution strategy.Root Spring Boot autoconfiguration for the failover framework.
Abstraction over the system clock used by the failover framework for computing
and comparing expiry timestamps.
Strategy for executing a method call with failover semantics.
Extracts expiry configuration (duration and unit) from a
@Failover annotation.Composite
ExpiryPolicy that delegates to a named policy from the lookup when
@Failover#expiryPolicy() is set, falling back to the default policy otherwise.Spring Boot
FailureAnalyzer that produces
actionable startup diagnostics when a required failover bean is missing.Core handler for failover lifecycle operations: storing payloads, recovering them on failure,
and cleaning up expired entries.
Spring Boot Actuator
HealthIndicator for the failover framework.Primary
KeyGenerator that orchestrates key generation for a failover operation.MeterBinder that exposes static failover configuration as Micrometer gauges.Autoconfiguration for Micrometer-based failover metrics.
Resolves the effective store namespace for a
Failover annotation.Publishes a startup summary of all detected
@Failover configurations.Root configuration properties for the failover framework, bound to the
failover prefix.Scans the application classpath for methods annotated with
Failover
and provides lookup by name.Thrown when the
FailoverScanner encounters an error during Spring context scanning
or detects duplicate @Failover names.Persistence contract for failover referential data.
FailoverStore decorator that offloads write operations (FailoverStoreAsync.store(com.societegenerale.failover.core.payload.ReferentialPayload<T>),
FailoverStoreAsync.delete(com.societegenerale.failover.core.payload.ReferentialPayload<T>), FailoverStoreAsync.cleanByExpiry(java.time.Instant)) to a TaskExecutor, keeping the calling
thread unblocked.Central assembler that creates the single
FailoverStore<Object> bean by
combining a TenantStoreFactory (raw store) with the standard decorator chain
(DefaultFailoverStore + optionally FailoverStoreAsync and/or MultiTenantFailoverStore).FailoverStore implementation backed by a single Caffeine in-memory cache.Thrown when a
FailoverStore operation (store, find, delete, or clean) fails.FailoverStore implementation backed by a plain ConcurrentHashMap.JDBC-backed
FailoverStore implementation.Autoconfiguration that activates when
failover.store.multitenant.enabled=true.Contract for resolving JDBC queries, binding parameters, and mapping result-set rows
for the failover store.
This describes the type of failover
TenantResolver that always returns the same literal tenant ID.JDBC store configuration properties.
Jackson-backed
Serializer that converts payloads to/from JSON using a provided
ObjectMapper.Strategy interface for generating a cache key from a failover operation's method arguments.
Strategy for resolving a
KeyGenerator by qualifier or bean name.Thrown when no
KeyGenerator bean is found for the qualifier specified in a @Failover annotation.Extracts build metadata from
META-INF/MANIFEST.MF for a given artifact title.ContextPropagator that propagates the SLF4J Mapped Diagnostic Context (MDC)
across executor boundaries in scatter/gather operations.AbstractObservablePublisher that publishes failover metrics by writing each metric
entry into the MDC before emitting a single INFO log line, then restoring the prior MDC state.Key-value bag for additional metadata attached to recovered failover payloads.
Carries all contextual information available at the point where a method exception is handled.
Default
MethodExceptionPolicy — graceful handling with no exception propagator.Strategy for deciding the final outcome after a primary method call fails and failover
recovery has been attempted.
Mutable key-value bag for failover metrics, keyed with a
"failover-" prefix.ContextPropagator that propagates the active Micrometer Span across
executor boundaries in scatter/gather operations.ObservablePublisher that emits real Micrometer meters on every store/recover event.Autoconfiguration that registers
MicrometerContextPropagator when
io.micrometer.tracing.Tracer is on the classpath and a Tracer bean exists.Multitenant failover store configuration — a
Store-level concern independent of
the backing store technology (JDBC, Caffeine, InMemory).Tenant isolation strategy for the JDBC store.
Outermost
FailoverStore decorator that routes every operation to the correct
per-tenant store.MethodExceptionPolicy that serves recovered data when available, and cascades
the original exception only when there is nothing to recover.SPI for publishing failover metrics to an external sink (log, metrics system, event bus, etc.).
Spring scheduler that periodically calls
FailoverObserver.observe() to collect
metrics from all registered @Failover configurations and publish them to all
registered ObservablePublisher beans.No-op
RecoveredPayloadHandler that returns the recovered payload unchanged.Strategy for resolving the SQL type and extracting the value of the PAYLOAD column.
Strategy for enriching payloads before they are stored or after they are recovered.
Strategy that splits a composite payload into individual slices for scatter/gather operations.
Thrown when a user-provided
PayloadSplitter raises an exception during
splitOnStore, splitOnRecover, or merge.Strategy for resolving a
PayloadSplitter by qualifier or bean name.Thrown when
PayloadSplitterLookup cannot resolve the PayloadSplitter
named in Failover.payloadSplitter().Post-processor for payloads recovered from the failover store.
Base class for referential entities which need to be aware of the failover metadata information.
Interface to be implemented by referential entities that wish to be aware of the failover
metadata information.
Envelope that wraps a referential payload with metadata used by the failover mechanism.
BasicFailoverExecution extension that wraps each supplier with a Resilience4j
CircuitBreaker named after the failover point.Autoconfiguration for the Resilience4j-based
FailoverExecution.Abstraction for locating classpath resources by name.
MethodExceptionPolicy that serves recovered data when available, and cascades
the original exception only when there is nothing to recover.Scatter/gather configuration for the failover framework.
FailoverHandler decorator that adds scatter/gather routing to
Failover-annotated methods.Scheduler configuration for the failover framework.
Strategy for serializing and deserializing business payloads to and from a storable
string representation (e.g.
FailoverScanner backed by the Spring ApplicationContext.Configuration properties for
failover.store.*.Immutable context passed to
PayloadSplitter.splitOnStore(com.societegenerale.failover.core.payload.splitter.StoreContext<T>) and produced by it.Per-tenant configuration overrides (JDBC only).
Thread-local holder for the current tenant ID.
ContextPropagator that propagates the current tenant ID from TenantContext
across executor boundaries in scatter/gather operations.TenantResolver that reads the current tenant ID from TenantContext.Strategy for resolving the current tenant identifier from the execution context.
SPI for creating a raw
FailoverStore for a given tenant.Default
PayloadColumnResolver that maps the PAYLOAD column as VARCHAR.