API reference

One sentence saying what went wrong.

@Resilience.Root.Failure — why a guarded execution produced no value

Whether the failure is a cancellation.

Whether the failure is a rejection by a strategy rather than the callback's own error.

The outcome of a callback that answers a plain Result.

@Resilience.Root.Outcome — the value or failure of one execution

An outcome holding the callback's own error.

The callback's own error, when the failure is one.

An outcome holding a value.

One line naming an outcome, for telemetry.

Enabled, injecting into every execution.

The arguments chaos generators receive for one execution.

@Resilience.Chaos.Arguments — what a chaos generator decides from

Enabled, injecting into the given share of executions, from 0 to 1.

Enabled, injecting into one execution in a thousand.

@Resilience.Chaos.Injection — how often, and whether, chaos is injected

Whether to inject into the execution holding context: never while disabled, otherwise with

the probability the rate names. A generated rate outside 0 to 1 is taken as the nearer bound.

Every reason the injection settings cannot be followed.

The default injection with no behavior chosen yet.

Runs behavior at the given injection settings.

@Chaos.Behavior.Options — what to run and how often

A behavior injection strategy following the options. A behavior that fails answers its

failure without running the callback.

Every reason the options cannot be followed.

The default injection with no failure chosen yet.

@Chaos.Fault.Injected — the failure injected into one execution

Injects failure at the given injection settings.

@Chaos.Fault.Options — which failure to inject and how often

A fault injection strategy following the options. The generator is used when given; a

generator answering nothing injects nothing.

Every reason the options cannot be followed.

Thirty seconds at the default injection.

@Chaos.Latency.Injected — the delay injected into one execution

Injects millis of delay at the given injection settings.

@Chaos.Latency.Options — how long to delay and how often

A latency injection strategy following the options. A delay of zero or less injects

nothing; a token firing during the delay answers Cancelled without running the callback.

Every reason the options cannot be followed.

The default injection with no outcome chosen yet.

@Chaos.Outcome.Injected — the outcome injected into one execution

Injects outcome at the given injection settings.

@Chaos.Outcome.Options — which outcome to inject and how often

An outcome injection strategy following the options. The generator is used when given; a

generator answering nothing injects nothing.

Every reason the options cannot be followed.

A generator answering each value with a chance in proportion to its weight. Weights below

one are never chosen; with no positive weight it answers nothing.

@Resilience.CircuitBreaker.BreakArguments — the health a break duration is chosen from

@Resilience.CircuitBreaker.CircuitState — which executions a circuit admits

Closes every circuit the control holds.

@Resilience.CircuitBreaker.Closing — what closed a circuit

Opens at a tenth of at least 100 executions failing within 30 seconds, for 5 seconds.

Whether the control last isolated its circuits.

Isolates every circuit the control holds, and every circuit attached to it later, until closed.

The last outcome the provider's circuit handled, while the circuit is not closed.

A manual control holding no circuit, not isolated.

@Resilience.CircuitBreaker.ManualControl — isolates and closes circuits by hand

@Resilience.CircuitBreaker.Opening — why and for how long a circuit opened

@Resilience.CircuitBreaker.Options — when a circuit opens and for how long

The state of the provider's circuit, or None before it is attached.

A state provider attached to no circuit.

@Resilience.CircuitBreaker.StateProvider — reads the state of one circuit

A circuit breaker strategy following the options. Every pipeline holding the same strategy

shares its one circuit.

Every reason the options cannot be followed, not counting an attached state provider.

Moves a manual clock forward by millis; a negative amount moves it by nothing.

@Resilience.Clock.Clock — reads time and waits in milliseconds

A manual clock reading start milliseconds until it is advanced.

@Resilience.Clock.Manual — time that moves only when told

The clock's reading, in milliseconds.

A clock driven by a manual clock. Waiting records the requested wait and advances the manual

clock by it at once; it answers the token's reason when the token has fired.

Waits millis on the clock, or until the token fires; the token's reason when it fired.

Every wait requested of a manual clock, oldest first.

The monotonic clock of the running program. Waiting ends early when the token fires.

Reported after each attempt a retry or hedging strategy makes.

Reported when a behavior is injected.

Reported when a circuit closes.

Reported when a circuit admits its half-open probe.

Reported when a circuit opens.

Reported before a fallback strategy produces its substitute.

Reported when a fault is injected.

Reported before a hedging strategy starts a hedged attempt.

Reported when latency is injected.

Reported when an outcome is injected.

Reported when a rate limiter strategy rejects an execution.

Reported before a retry strategy waits for its next attempt.

Reported when a timeout strategy cancels an execution.

Reported when a pipeline finishes an execution.

Reported when a pipeline starts an execution.

An open circuit; <1> is the wait in milliseconds before it may be tried again.

A cancellation; <1> is its reason.

A callback that stopped its thread; <1> is what it said.

An isolated circuit.

A pipeline refused at build time; <1> is its problems.

What separates problems listed in one sentence.

A failure raised by the callback; <1> is the error.

A rate limiter rejection without a known wait.

A rate limiter rejection with a known wait; <1> is the wait in milliseconds.

A registry key whose pipeline is refused; <1> is the key and <2> its problems.

A registry key without a builder; <1> is the key.

An outcome holding a value; <1> is the value.

A timeout; <1> is the timeout in milliseconds.

Copies every property of source into target, replacing properties of the same name.

A key holding a truth value.

Asks the execution holding this context to stop. The first reason given is kept.

A fresh context whose execution stops when token fires.

Ok while the token has not fired, and Cancelled once it has, so a callback stops with ?.

@Resilience.Context.Context — what one execution carries through a pipeline

A context with no operation key, a token that fires only when cancelled, and no properties.

A copy of the context observing another token, with a separate copy of its properties.

The property under a key, when it is present and reads back as the key's type.

The property under a key, or fallback when it is absent or unreadable.

Whether a property is stored under the key's name.

A key holding a whole number.

A key whose values are written with encode and read back with decode.

@Resilience.Context.Key — a typed name for one property

A fresh context naming the operation it runs.

The names of every stored property, in order.

Sleeps millis on the system clock, or answers Cancelled as soon as the token fires.

Removes the property under a key.

Stores a property, replacing any value under the same name.

Whether the context's token has fired.

A key holding text.

The same context observing another token; properties stay shared with the original.

@Domain.Algorithms.Bucket — tokens left and when they were last topped up

Permits held while an execution runs and handed back when it ends.

At most limit permits in each window of window milliseconds, the window moving by itself

when automatic and otherwise only when replenished by hand.

@Domain.Algorithms.Segments — permits used per segment, oldest first

Segment counts after steps segments have passed: the oldest drop out and empty ones join.

At most limit permits in any window milliseconds, counted in segments equal segments;

the segments move by themselves when automatic and otherwise only when replenished by hand.

A bucket of at most limit tokens gaining perPeriod tokens every period milliseconds,

by itself when automatic and otherwise only when replenished by hand.

@Domain.Algorithms.Window — permits used since the window began

The delay before retry attempt, counting from 0, and the jitter state for the next one.

state starts at 0.0 for a run of retries; draw is a uniform number from 0 up to 1.

@Domain.Backoff.Plan — the inputs every delay is computed from

@Domain.Backoff.Shape — how the delay grows with each retry

The delay before retry attempt without jitter.

@Domain.Circuit.Admission — the answer to one execution asking to run

Whether an execution may run at now. An open circuit past its deadline turns half-open and

admits this one execution as its probe, pushing the deadline breakDuration further; every

other execution waits for the probe's outcome.

The circuit closed, with its counts and half-open attempts cleared.

A closed circuit counting over a sampling period of sampling milliseconds.

The circuit after a handled outcome at now, and whether it must now open: always from

half-open, and from closed once the thresholds are met. The failure is counted except while

half-open.

The circuit held open until closed by hand.

@Domain.Circuit.Machine — the circuit's phase, deadline, and counts

The circuit opened at now for duration milliseconds.

@Domain.Circuit.Phase — which executions the circuit admits

Milliseconds until the circuit may admit a probe, never below zero.

The circuit after an unhandled outcome at now, and whether it closed. A half-open circuit

closes; the outcome is counted in every phase.

@Domain.Circuit.Thresholds — when a closed circuit opens

Empty counts over a sampling period of sampling milliseconds.

The share of failures in the totals, to six places; zero without throughput.

@Domain.Health.Health — the windows covering one sampling period

The totals of the windows still inside the sampling period at now.

@Domain.Health.Info — totals over the sampling period

The counts with one more outcome recorded at now.

The counts emptied.

Whether the totals reach the minimum throughput and a failure share of at least ratio.

@Domain.Health.Window — the counts of one slice of the sampling period

@Domain.Permits.Algorithm — how one kind of limiter counts permits

The permits available at now.

@Domain.Permits.Book — a limiter's counts and queue

@Domain.Permits.Decision — the answer to a new request

The book with permits handed back.

A book with no waiters over the algorithm state held.

@Domain.Permits.Order — which waiter is served first

The book at now after the waiter holding ticket asks again. It takes its permits when it

is next in order and they are available.

The permits all waiters are asking for.

The book after one replenishment by hand, and whether the algorithm allows it.

The book at now after a request for permits. The request is granted when the permits are

available and no waiter comes first; otherwise it joins the queue when mayQueue and the

queue has room, evicting the oldest waiters when newest requests are served first; otherwise

it is denied. A request for more than the permit limit is always denied, and a request for no

permits is granted while any permit is available.

@Domain.Permits.Turn — the answer to a waiter asking again

@Domain.Permits.Waiter — one queued request

The book without the waiter holding ticket, counted as failed.

Handles every failure except a cancellation; the action must still be given.

@Resilience.Fallback.Options — what to handle and what to answer instead

A fallback strategy following the options.

Every reason the options cannot be followed.

Answers value in place of every failure except a cancellation.

@Resilience.Hedging.Action — what a hedged attempt is generated from

One hedged attempt, started after two seconds, for every failure except a cancellation.

@Resilience.Hedging.DelayArguments — the attempt a hedging delay is chosen for

@Resilience.Hedging.Hedged — the hedged attempt about to start

@Resilience.Hedging.Options — how many attempts to race and when to start them

A hedging strategy following the options.

Every reason the options cannot be followed.

A delay that starts the next hedged attempt only once an earlier attempt's outcome is handled.

@Hedging.Attempts.Attempt — one running execution of a hedged callback

A wait that ends only when an attempt finishes.

Starts callback on a thread of its own with context. When it finishes, its outcome is

stored and index is sent to finished; a callback that stops its thread finishes as

Crashed, and one that cannot be started finishes at once as Crashed.

The index of the next attempt to finish, or None when wait milliseconds pass on the clock

first. A wait of FOREVER waits for as long as it takes.

The outcome of a finished attempt.

Asks every attempt to stop and waits until each thread has ended.

Requests permits, waiting in the limiter's queue while it has room; the lease is

Abandoned when the token fires first.

Requests permits without waiting.

A limiter granting a request only when every limiter in order grants it. A refusal releases

the leases already taken and answers that refusal.

@Resilience.Limiter.Grant — whether a request was given its permits

@Resilience.Limiter.Grant — whether a request was given its permits

A lease granted with handBack run on its first release only.

Whether the lease holds its permits.

@Resilience.Limiter.Lease — the answer to one request and how to hand its permits back

@Resilience.Limiter.Limiter — leases permits, waiting or at once

@Resilience.Limiter.QueueOrder — which queued request is served first

A lease that holds nothing and releases nothing.

Hands a lease's permits back. Releasing twice hands them back once.

Adds one period's permits to a limiter replenished by hand; whether it did.

The limiter's counts now.

@Resilience.Limiter.Statistics — a limiter's counts at one moment

A concurrency limiter following the options, or every reason it cannot be made.

A thousand permits, no queue, oldest first, on the system clock.

@Limiter.Concurrency.Options — permits held at once and the queue behind them

Every reason the options cannot be followed.

A limiter over algorithm, starting from held, reading time from clock.

@Limiter.Engine.Queueing — the limits every engine enforces

A fixed window limiter whose first window starts now, or every reason it cannot be made.

A hundred permits a second, moving by itself, with no queue.

@Limiter.FixedWindow.Options — permits per window and the queue behind them

Every reason the options cannot be followed.

Requests permits from the partition of the context, waiting as that limiter allows.

Requests permits from the partition of the context without waiting.

A partitioned limiter choosing each execution's partition with partitionOf.

The keys of every partition used so far, in order.

@Limiter.Partitioned.Partition — the key of a partition and how to make its limiter

@Limiter.Partitioned.Partitioned — limiters made on first use, one per key

The counts of a partition's limiter, once it has been used.

A sliding window limiter whose first segment starts now, or every reason it cannot be made.

A hundred permits in any second, counted in ten segments, with no queue.

@Limiter.SlidingWindow.Options — permits per window, its segments, and the queue

Every reason the options cannot be followed.

A token bucket limiter starting full, or every reason it cannot be made.

A full bucket of ten tokens gaining ten every second by itself, with no queue.

@Limiter.TokenBucket.Options — the bucket's size, refill, and queue

Every reason the options cannot be followed.

The pipeline as one strategy of another. It keeps its own clock and telemetry.

A pipeline of strategies with the default options. The first strategy is the outermost.

A pipeline of strategies with the given options, or every problem found in the options of

its strategies and every strategy name used twice.

No name, the system clock and randomizer, and no listeners.

The name, instance, and strategies of a pipeline, outermost first.

@Resilience.Pipeline.Described — one strategy of a built pipeline

@Resilience.Pipeline.Descriptor — what a built pipeline is made of

A pipeline with no strategies: it runs every callback once, as given.

Runs a callback through the pipeline with a fresh context.

Runs a callback through the pipeline with the given context, reporting the execution's start

and, with its duration and outcome, its end.

One line per problem.

@Resilience.Pipeline.Invalid — every reason a pipeline could not be built

@Resilience.Pipeline.Invalid — every reason a pipeline could not be built

@Resilience.Pipeline.Options — identity, effects, and telemetry of a pipeline

@Resilience.Pipeline.Pipeline — strategies composed outermost first

Runs a callback that answers a plain Result through the pipeline with a fresh context; its

error becomes Raised.

run with the given context.

Outcomes that any of tests handles; none when tests is empty.

Every error the callback raises itself.

The arguments for judging one outcome. attempt counts from 0 for the first execution.

@Resilience.Predicate.Arguments — the outcome being judged and where it arose

Rejections by an open or isolated circuit.

The failures, of any kind, that test accepts.

Every failure except a cancellation; no value. The default of every reactive strategy.

Whether test handles the outcome.

Handles nothing.

@Resilience.Predicate.Predicate — answers whether a strategy handles an outcome

The callback's own errors that test accepts.

Rejections by a rate limiter.

The values equal to expected.

The values that test accepts.

Rejections by a timeout strategy.

A whole number from zero up to, but not including, bound; zero for a bound below one.

Whether a draw falls below rate, a ratio from 0 to 1. A rate of 1 always holds and a rate

of 0 never does.

A randomizer whose every draw is ratio of the bound, rounded down. ratio is clamped to

the range from 0 up to just below 1.

A fraction of one in parts of SCALE, from zero up to but not including SCALE.

@Resilience.Randomizer.Randomizer — answers a whole number below a bound

The number of parts one unit is divided into by fraction.

A randomizer that draws the same sequence for the same seed.

A randomizer seeded from the clock, safe to share between threads.

A float from zero up to but not including one.

One permit per execution from a concurrency limiter of permitLimit permits and a queue of

queueLimit.

One permit per execution from a concurrency limiter of a thousand permits and no queue.

@Resilience.RateLimiter.Options — where permits come from and who hears of rejections

One permit per execution from the limiter of its partition.

@Resilience.RateLimiter.Rejected — the execution a limiter turned away

A rate limiter strategy following the options. Every pipeline holding the same strategy

shares its default limiter.

One permit per execution from limiter, waiting as it allows.

@Resilience.Registry.Builder — the strategies of the pipeline for one key

@Resilience.Registry.BuilderContext — the key a pipeline is being built for

An empty registry with the default options.

An empty registry with the given options.

The default pipeline settings, each key as its builder name, and no instance name.

One sentence saying why a pipeline could not be answered.

The pipeline for a key, built from its builder on first use and shared afterwards.

The pipeline for a key, registering builder first when the key has none.

Every key with a builder, in order.

@Resilience.Registry.Options — shared pipeline settings and how keys become names

@Resilience.Registry.Registry — builders and the pipelines built from them

@Resilience.Registry.RegistryError — why a pipeline could not be answered

A new pipeline for a key, built again from its builder; later get calls answer it. State

such as an open circuit starts afresh in the new pipeline.

Registers the builder for a key; false, changing nothing, when the key already has one.

The pipeline for a key, or None when the key has no builder or its pipeline is invalid.

@Resilience.Retry.Backoff — how the delay grows with each retry

Three retries of every failure except a cancellation, two seconds apart, without jitter.

@Resilience.Retry.Options — when to retry and how long to wait

@Resilience.Retry.Retrying — the attempt that failed and the wait before the next

A retry strategy following the options.

A retry count that never runs out.

Every reason the options cannot be followed.

@Resilience.Strategy.Callback — the work a layer guards

A strategy of the given kind that runs execute around every callback. name identifies it

in telemetry and must be unique within one pipeline.

Keeps nothing of the runtime; the attach of a strategy that holds no state between calls.

@Resilience.Strategy.Execute — runs a callback under one layer's policy

@Resilience.Strategy.Runtime — the effects a pipeline lends its layers

A runtime on the system clock and randomizer that reports nothing.

@Resilience.Strategy.Strategy — a named, validated policy layer

@Resilience.Telemetry.Detail — what each kind of event measured

@Resilience.Telemetry.Event — one reported occurrence

The same reporter naming another strategy as the source.

@Resilience.Telemetry.Listener — receives every reported event

The rank of a severity, from 0 for Silent to 5 for Critical.

Reports one event from the reporter's source about the execution holding context.

A reporter for source that gives each event the severity severityOf answers, when given,

and hands every event not Silent to each listener in order.

@Resilience.Telemetry.Reporter — where one strategy's events go

@Resilience.Telemetry.Severity — how much an event matters

The severity's name.

A reporter that drops every event.

@Resilience.Telemetry.Source — the pipeline and strategy reporting

The source as one dotted name, leaving out the parts it lacks.

One line naming an event's severity, name, source, operation, detail, and outcome.

A listener writing every event of at least the least severity as one line.

How many events of the given name were counted, over every series.

A meter naming each series by event name and source.

Every duration recorded for events of the given name, in the order they were reported.

A meter that also names each series by the tags enrich answers for its event.

A listener counting every event into the meter, and recording the duration of every attempt

and every finished execution.

@Telemetry.Meter.Meter — event counts and durations by series

Every series and its count, in order.

A timeout of millis.

A thirty-second timeout.

@Resilience.Timeout.Elapsed — the execution a timeout cancelled

@Resilience.Timeout.Options — how long a callback may run

A timeout strategy following the options.

Every reason the options cannot be followed.

left + right, or LARGEST when the sum would exceed it. Both are at least zero.

The largest count or duration the package represents.

left * right, or LARGEST when the product would exceed it. Both are at least zero.

The count of parts per whole that ratio names, rounded down. ratio is between 0 and 1.

The float nearest to an integer.

The whole part of a float, clamped to zero below and to LARGEST above; LARGEST for a

value that is not finite.

Replaces the value with the first half of what step answers for it, and answers the second

half. No other change to the same value runs between the read and the write.

The value as it stands.

A shared value starting at initial.

@Utils.Shared.Shared — a value changed only under its lock

Replaces the value with what step answers for it.

The template with each <n> replaced by the nth value, counting from 1, in one pass: text

taken from a value is never filled again. A slot without a value is kept as written.