Struct RetryPolicy 

pub struct RetryPolicy {
    pub max_attempts: u32,
    pub initial_backoff: Duration,
    pub max_backoff: Duration,
    pub multiplier: u32,
    pub jitter: bool,
    pub max_advice: Duration,
}

How many times to repeat a failed effect, and how far apart.

The defaults are safe rather than timid: three attempts with exponential backoff. They are safe because Disposition gates them — an effect whose failure is in-doubt is not repeated under this policy unless its Recovery permits guessing, no matter what max_attempts says.

Fields

max_attempts: u32

Total attempts including the first. 1 means “never repeat”.

initial_backoff: Duration

Delay before the second attempt.

max_backoff: Duration

Ceiling on the delay, however many attempts have passed.

Also the bound on how long one effect holds a worker — see the module docs. For waits longer than a few seconds, the run should suspend instead: that is StepCtx::sleep, not a retry policy.

multiplier: u32

Growth factor per attempt. An integer, so the schedule is exactly reproducible on any platform without depending on float rounding.

jitter: bool

Whether to spread the delay across runs. See the module docs — this is derived from a hash, not drawn from an RNG.

max_advice: Duration

The longest this run will wait because a peer named a time.

A separate ceiling from max_backoff, because the two bound different risks. max_backoff bounds a guess: nobody knows when the service recovers, so waiting long is waste. This bounds somebody else’s word — a Retry-After from the one party with an interest in never being called again — and the number that makes the wait useful is theirs, not ours. Sharing one ceiling would mean either guessing for as long as a peer may demand, or discarding advice that is merely longer than a guess would have been.

A minute covers every published provider rate-limit window and is short enough that a hostile or broken value costs one wasted minute of one worker. Advice past it is clamped, not discarded: waiting part of a window is closer to right than ignoring it, and if the window really was longer the next refusal names what is left.

Raising it holds a worker for that long. A rate limit measured in more than minutes is not a retry at all — that is StepCtx::sleep, which costs a row.

Implementations

impl RetryPolicy

pub const fn never() -> Self

Never repeat. The first failure is final.

The right choice for an effect that is expensive, externally rate limited, or whose driver already retries internally — a policy stacked on a driver that retries is a multiplication, not an addition.

pub fn attempts(n: u32) -> Self

n total attempts with the default backoff schedule.

pub fn with_backoff(self, initial: Duration, max: Duration) -> Self

Replace the backoff schedule, keeping the attempt count.

pub fn without_jitter(self) -> Self

Turn jitter off, making the schedule identical across runs.

pub const fn wait_at_most(self, advice: Duration) -> Self

Change how long a peer’s own Retry-After may hold a worker.

See max_advice for why this is not max_backoff.

pub fn wait_before( &self, run: RunId, key: EffectKey, attempt: u32, advice: Option<Duration>, ) -> Duration

How long to wait before attempt, given whatever the peer said.

advice wins when present, clamped to max_advice, including when it is shorter than the computed backoff: the peer is describing its own recovery, and waiting longer than it asked buys nothing.

pub fn permits(&self, attempt: u32) -> bool

Whether another attempt is left after attempt has failed.

attempt is 1-based, matching what the journal records.

pub fn backoff(&self, run: RunId, key: EffectKey, attempt: u32) -> Duration

How long to wait before attempt (1-based; attempt 1 never waits).

Exponential with an integer multiplier and a ceiling, then optionally spread by a hash-derived factor in [0.5, 1.0] of the computed delay. Halving rather than scaling from zero keeps a floor under the schedule: full jitter can pick a near-zero delay and hammer a service that is already struggling.

Trait Implementations

impl Clone for RetryPolicy

fn clone(&self) -> Self

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

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RetryPolicy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RetryPolicy

impl PartialEq for RetryPolicy

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RetryPolicy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RetryPolicy