Struct RetryPolicy 

pub struct RetryPolicy {
    pub max_attempts: usize,
    pub initial_backoff: Duration,
    pub max_backoff: Duration,
    pub max_elapsed_time: Duration,
    pub backoff_factor: f64,
    pub jitter: bool,
    pub backoff_kind: BackoffKind,
    pub linear_increment: Duration,
    pub retry_if: Option<Arc<dyn Fn(&AppError) -> bool + Sync + Send>>,
    pub on_retry: Option<Arc<dyn Fn(u32, &AppError) + Sync + Send>>,
    pub jitter_seed: Option<u64>,
}

Retry policy with configurable backoff and retry predicate.

Example

let policy = RetryPolicy::new()
    .with_max_attempts(3)
    .with_initial_backoff(std::time::Duration::from_millis(100));

let result = policy.execute(|| async {
    Ok::<_, rskit_errors::AppError>(42)
}).await;

Fields

max_attempts: usize

Maximum number of attempts before giving up (including the first call).

initial_backoff: Duration

Delay before the first retry.

max_backoff: Duration

Upper bound on any single backoff delay.

max_elapsed_time: Duration

Upper bound on total retry elapsed time, including the first attempt.

backoff_factor: f64

Multiplier applied on each successive retry when using exponential backoff.

jitter: bool

Whether to add uniform jitter to each backoff delay.

backoff_kind: BackoffKind

Backoff algorithm applied between retry attempts.

linear_increment: Duration

Linear increment applied when BackoffKind::Linear is selected.

retry_if: Option<Arc<dyn Fn(&AppError) -> bool + Sync + Send>>

Predicate that decides whether a given error is worth retrying. When None, defaults to AppError::is_retryable().

on_retry: Option<Arc<dyn Fn(u32, &AppError) + Sync + Send>>

Called after each failed attempt before the next backoff sleep. Arguments: (attempt_number, error).

jitter_seed: Option<u64>

Seed used to make jitter deterministic across runs.

Implementations

impl RetryPolicy

pub fn new() -> RetryPolicy

Create a new RetryPolicy with default settings.

pub fn from_preset(preset: RetryPreset) -> RetryPolicy

Create a policy from a named retry preset.

pub fn fast() -> RetryPolicy

Create a short retry loop for local tests and latency-sensitive operations.

pub fn standard() -> RetryPolicy

Create a balanced default policy for service-to-service calls.

pub fn external_service() -> RetryPolicy

Create a more tolerant policy for external network dependencies.

pub fn with_max_attempts(self, n: usize) -> RetryPolicy

Set the maximum number of attempts (including the first call).

pub fn with_initial_backoff(self, d: Duration) -> RetryPolicy

Set the initial backoff delay before the first retry.

pub fn with_max_backoff(self, d: Duration) -> RetryPolicy

Set the upper bound on any single backoff delay.

pub fn with_max_elapsed_time(self, d: Duration) -> RetryPolicy

Set the total elapsed-time cap for all attempts and backoff sleeps.

pub fn with_backoff_factor(self, f: f64) -> RetryPolicy

Set the exponential backoff multiplication factor.

pub fn with_jitter(self, enabled: bool) -> RetryPolicy

Enable or disable uniform jitter on each backoff delay.

pub const fn with_jitter_seed(self, seed: u64) -> RetryPolicy

Set a deterministic seed for retry jitter.

pub fn with_constant_backoff(self, backoff: ConstantBackoff) -> RetryPolicy

Use a fixed delay for every retry attempt.

pub fn with_linear_backoff(self, backoff: LinearBackoff) -> RetryPolicy

Use a linearly increasing retry delay.

pub fn with_retry_if( self, f: impl Fn(&AppError) -> bool + Send + Sync + 'static, ) -> RetryPolicy

Override the predicate used to decide whether an error is retryable.

pub fn with_on_retry( self, f: impl Fn(u32, &AppError) + Send + Sync + 'static, ) -> RetryPolicy

Register a callback called after each failed attempt before the next backoff sleep. Arguments passed: (attempt_number, error).

pub async fn execute<F, Fut, T>(&self, f: F) -> Result<T, RetryError>

where F: FnMut() -> Fut, Fut: Future<Output = Result<T, AppError>>,

Execute f, retrying on retryable AppErrors according to this policy.

Returns Ok(T) on first success, or Err(RetryError) when exhausted.

pub fn backoff_delay(&self, attempt: usize) -> Duration

Return the retry delay for a one-based failed attempt number.

pub fn validate(&self) -> Result<(), AppError>

Validate retry policy limits.

Errors

Returns an error when attempts or backoff parameters are invalid.

Trait Implementations

impl Clone for RetryPolicy

fn clone(&self) -> RetryPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RetryPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for RetryPolicy

fn default() -> RetryPolicy

Returns the “default value” for a type.