Struct RetryConfig 

#[non_exhaustive]
pub struct RetryConfig {
    pub initial: Duration,
    pub max: Duration,
    pub multiplier: f64,
    pub jitter: f64,
    pub max_attempts: u32,
}

Retry policy for batch writes. Retries rotate across healthy replicas; the sealed batch and its deduplication token are reused unchanged.

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.

initial: Duration

First backoff delay.

max: Duration

Backoff cap.

multiplier: f64

Backoff growth factor per attempt.

jitter: f64

Fraction of the delay randomized away (0.0..=1.0).

max_attempts: u32

Total write attempts before the batch is abandoned (acknowledgments failed, watermark stalls). 0 means unbounded, retrying until the drain deadline, at which point the attempt in flight is aborted and the batch abandoned. The at-least-once default.

An unbounded policy holds its in-flight slot (InflightConfig::max_per_shard) for the whole outage, since a slot frees only when its write task ends. That is how a down sink back-pressures the source rather than buffering, and it means a shard talking to a dead sink runs at zero in-flight capacity until either the sink recovers or the drain deadline arrives.

Implementations

impl RetryConfig

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

Reject a retry policy that would misbehave at runtime. Connectors call this from their config validation and prepend their own config path to the message, so the rules stay in one place instead of being mirrored per connector.

This is about intent, not safety. Backoff never panics for any RetryConfig and always saturates at max. It returns a zero delay only for a policy this rejects (initial or max of zero), so “never zero” is a property of a validated policy, not of the type. What it catches is a policy no operator means: a sub-1.0 multiplier shrinks the delay instead of backing off, a zero delay is not a backoff at all, and both are worth failing at load rather than at 3am.

The bounds are generous and do not guarantee a sensible policy. initial: 1ns, max: 1ns passes. They rule out the nonsensical, not the aggressive.

Errors

RetryConfigError, naming the offending key.

use spate_core::sink::{RetryConfig, RetryConfigError};

assert!(RetryConfig::default().validate().is_ok());

let mut hot_loop = RetryConfig::default();
hot_loop.multiplier = 0.5;
assert_eq!(hot_loop.validate(), Err(RetryConfigError::Multiplier(0.5)));

Trait Implementations

impl Clone for RetryConfig

fn clone(&self) -> RetryConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RetryConfig

impl Debug for RetryConfig

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

Formats the value using the given formatter.

impl Default for RetryConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RetryConfig

where RetryConfig: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RetryConfig

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RetryConfig