JitterModifier Class

Namespace
Kampute.Resilience.Strategies.Modifiers
Assembly
  • Kampute.Resilience.dll

Definition

A retry strategy that adds random jitter to the delays of another retry strategy.
public sealed class JitterModifier : IRetryStrategy
Inheritance
Implements

Remarks

Jitter spreads retry attempts over time. When many operations fail at the same moment and share a strategy, jitter keeps them from all retrying at the same moment again.

Constructors

JitterModifier(IRetryStrategy, double)

Initializes a new instance of the JitterModifier class with a specified inner retry strategy and jitter factor.
public JitterModifier(IRetryStrategy innerStrategy, double jitterFactor)

Parameters

innerStrategy IRetryStrategy
The retry strategy whose delays are jittered.
jitterFactor double
The factor to apply to the delay to introduce jitter, represented as a value between 0 and 1.

Exceptions

ArgumentNullException
Thrown if innerStrategy is null.
ArgumentOutOfRangeException
Thrown if jitterFactor is not between 0 and 1.

Remarks

The jitter factor allows fine-tuning of the randomness applied to the retry delay, enabling a balance between predictability and the benefits of desynchronization. It is a double value between 0 and 1 that determines the maximum proportion of the delay that can be adjusted randomly to introduce jitter. A value of 0 means no jitter, while 1 allows the delay to vary by up to ±100% of the base delay.

Properties

InnerStrategy

Gets the retry strategy whose delays are jittered.
public IRetryStrategy InnerStrategy { get; }

Property Value

IRetryStrategy
The IRetryStrategy that decides whether to retry and the delay to which jitter is added.

JitterFactor

Gets the factor to apply to the delay to introduce jitter.
public double JitterFactor { get; }

Property Value

double
The factor to apply to the delay to introduce jitter. It is a floating-point number between 0 and 1, inclusive.

Methods

TryGetRetryDelay(TimeSpan, uint, out TimeSpan)

Calculates the delay for the next retry attempt, adding random jitter based on the jitter factor to the delay provided by the inner strategy.
public bool TryGetRetryDelay(TimeSpan elapsed, uint retryCount, out TimeSpan delay)

Parameters

elapsed TimeSpan
The total time elapsed since the start of retry attempts.
retryCount uint
The number of retries made so far, not counting the initial attempt.
delay TimeSpan
When this method returns, contains the calculated delay for the next retry attempt. This parameter is passed uninitialized.

Returns

bool
true if the inner strategy indicates that a retry should be attempted; otherwise, false.

Extension Methods

Execute(this IRetryStrategy, Action<CancellationToken>, CancellationToken)Runs a blocking operation and retries it as the strategy decides when it throws an exception.
Execute<T>(this IRetryStrategy, Func<CancellationToken, T>, CancellationToken)Runs a blocking operation that returns a value and retries it as the strategy decides when it throws an exception.
Execute<TState>(this IRetryStrategy, TState, Action<TState, CancellationToken>, CancellationToken)Runs a blocking operation that receives a state, and retries it as the strategy decides when it throws an exception.
Execute<TState, T>(this IRetryStrategy, TState, Func<TState, CancellationToken, T>, CancellationToken)Runs a blocking operation that receives a state and returns a value, and retries it as the strategy decides when it throws an exception.
ExecuteAsync(this IRetryStrategy, Func<CancellationToken, Task>, CancellationToken)Runs an asynchronous operation and retries it as the strategy decides when it throws an exception.
ExecuteAsync<T>(this IRetryStrategy, Func<CancellationToken, Task<T>>, CancellationToken)Runs an asynchronous operation that returns a value and retries it as the strategy decides when it throws an exception.
ExecuteAsync<TState>(this IRetryStrategy, TState, Func<TState, CancellationToken, Task>, CancellationToken)Runs an asynchronous operation that receives a state, and retries it as the strategy decides when it throws an exception.
ExecuteAsync<TState, T>(this IRetryStrategy, TState, Func<TState, CancellationToken, Task<T>>, CancellationToken)Runs an asynchronous operation that receives a state and returns a value, and retries it as the strategy decides when it throws an exception.
OnRetry(this IRetryStrategy, Action<RetryContext>)Creates a retry policy that retries every exception and invokes a handler for each approved retry.
OverrideDelay(this IRetryStrategy, Func<RetryContext, TimeSpan>)Creates a retry policy that retries every exception, replacing the strategy's delay with one computed from the failed attempt.
RetryOn<TException>(this IRetryStrategy)Creates a retry policy that retries the exceptions of the specified type as the strategy decides.
RetryOn(this IRetryStrategy, Func<Exception, bool>)Creates a retry policy that retries the exceptions that satisfy a condition, as the strategy decides.
RetryOn<TException>(this IRetryStrategy, Func<TException, bool>)Creates a retry policy that retries the exceptions of the specified type that satisfy a condition, as the strategy decides.
RetryOnResult<T>(this IRetryStrategy, Func<T, bool>)Creates a retry policy for operations returning T that retries every exception and the results that satisfy a condition, as the strategy decides.
StartSession(this IRetryStrategy)Starts a retry session for one operation that the strategy governs.
WithJitter(this IRetryStrategy, double)Adds random jitter to the delays of a retry strategy.
WithMaxDelay(this IRetryStrategy, TimeSpan)Caps each delay of a retry strategy.
WithMaxDelay(this IRetryStrategy, int)Caps each delay of a retry strategy at a number of milliseconds.
WithMaxElapsedTime(this IRetryStrategy, TimeSpan)Limits the time during which a retry strategy allows retries.
WithMaxElapsedTime(this IRetryStrategy, int)Limits the time, in milliseconds, during which a retry strategy allows retries.
WithMaxRetries(this IRetryStrategy, uint)Limits the number of retries a retry strategy allows.