Struct RetryPolicy 

#[non_exhaustive]
pub struct RetryPolicy {
    pub max_attempts: u32,
    pub base_delay: Duration,
    pub multiplier: f64,
    pub jitter: f64,
    pub max_delay: Duration,
    pub max_retry_after: Duration,
}

Retry policy for [super::ProviderSet] dispatch, opt-in via crate::Providers::builder().retry(..).

When configured, a candidate provider that returns FinanceError::RateLimited is retried in place — honoring the error’s retry_after hint when present (capped by max_retry_after), or this policy’s own exponential-backoff-plus-jitter delay otherwise — up to max_attempts times before dispatch falls through to the next routed provider (or fails, if it was the last).

Other error kinds are never retried by this policy: a RateLimited is the one error a policy-level retry can reliably fix by waiting; anything else (auth failures, 5xx, not-found, …) is left to the existing sequential/parallel provider fallback.

Default is no retry — a Providers built without calling .retry(..) behaves exactly as before this policy existed.

Example

use finance_query::{Providers, RetryPolicy};
use std::time::Duration;

let providers = Providers::builder()
    .retry(RetryPolicy::new(3).base_delay(Duration::from_millis(500)))
    .build()
    .await?;

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

max_attempts: u32

Maximum number of attempts per provider candidate, including the first try. Values below 1 are treated as 1 (no retry).

base_delay: Duration

Delay before the first retry when the error carries no retry_after hint. Default: 500ms.

multiplier: f64

Multiplier applied to the delay after each retry (clamped to at least 1.0). Default: 2.0.

jitter: f64

Jitter fraction (0.0..=1.0) applied to the computed delay so many concurrent callers don’t retry in lockstep. Default: 0.2.

max_delay: Duration

Upper bound on the computed backoff delay. Default: 30s.

max_retry_after: Duration

Upper bound on an explicit retry_after hint. Separate from max_delay so a legitimate multi-minute hint is honored, while a hostile or buggy upstream can’t park the caller indefinitely. Default: 5 minutes.

Implementations

impl RetryPolicy

pub fn new(max_attempts: u32) -> Self

A policy allowing up to max_attempts tries per candidate provider, with sane defaults for the rest (500ms base delay, 2x multiplier, 20% jitter, 30s cap).

pub fn base_delay(self, delay: Duration) -> Self

Override the base delay (see RetryPolicy::base_delay field docs).

pub fn multiplier(self, multiplier: f64) -> Self

Override the backoff multiplier (see RetryPolicy::multiplier field docs).

pub fn jitter(self, jitter: f64) -> Self

Override the jitter fraction (see RetryPolicy::jitter field docs).

pub fn max_delay(self, max_delay: Duration) -> Self

Override the max delay cap (see RetryPolicy::max_delay field docs).

pub fn max_retry_after(self, max_retry_after: Duration) -> Self

Override the cap on an explicit retry_after hint (see RetryPolicy::max_retry_after field docs).

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 Copy for RetryPolicy

impl Debug for RetryPolicy

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

Formats the value using the given formatter.

impl PartialEq for RetryPolicy

fn eq(&self, other: &RetryPolicy) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RetryPolicy