Struct RetryPolicy 

pub struct RetryPolicy {
    pub max_attempts: u32,
    pub initial_backoff: Duration,
    pub max_backoff: Duration,
    pub max_total_delay: Duration,
}

How a client spaces out the attempts of a single send.

The delay before a retry doubles from RetryPolicy::initial_backoff and is capped by RetryPolicy::max_backoff; the actual delay is then drawn anywhere between zero and that ceiling, so that emitters which failed at the same moment do not come back at the same moment. Retrying stops as soon as the delays of the send would add up to more than RetryPolicy::max_total_delay.

Fields

max_attempts: u32

Attempts a single send makes at most, the first one included. 1 disables retrying.

Never more than MAX_ATTEMPTS_CAP, and never less than one.

initial_backoff: Duration

Ceiling of the delay before the first retry.

max_backoff: Duration

Ceiling no single delay ever exceeds, however many retries were made.

max_total_delay: Duration

Budget all the delays of one send share.

Implementations

impl RetryPolicy

pub const fn disabled() -> Self

A policy that never retries: one attempt, and the caller hears about whatever it returned.

pub fn attempts(&self) -> u32

Attempts this policy actually makes: RetryPolicy::max_attempts, brought back inside 1..=MAX_ATTEMPTS_CAP.

pub fn backoff_ceiling(&self, retry: u32) -> StdDuration

Ceiling of the delay before retry number retry, where 1 is the first retry.

It doubles from RetryPolicy::initial_backoff and never exceeds RetryPolicy::max_backoff, so the ceilings of successive retries never decrease.

pub fn delays(&self, draws: &[f64]) -> Vec<StdDuration>

The delays this policy waits between the attempts of one send, one per retry, given one random draw in [0, 1) per retry.

Each delay lands between zero and the ceiling of its retry, and the schedule is cut short as soon as the next delay would spend more than RetryPolicy::max_total_delay. There are therefore at most RetryPolicy::attempts - 1 delays, and they add up to at most max_total_delay.

A draw that is missing or is not a finite number is read as 1, which asks for the whole ceiling: an unusable source of randomness makes the client wait longer, never less.

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

Available on crate feature producer only.

fn default() -> Self

Four attempts spread over at most five seconds.

Three retries absorb the blips a webhook emitter meets in production (a connection reset, a rolling deployment answering 503) without holding the caller’s task for long, and the five-second budget bounds what the worst send costs whatever the individual delays turn out to be.

impl Eq for RetryPolicy

impl PartialEq for RetryPolicy

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RetryPolicy