Struct AdaptiveThrottler

pub struct AdaptiveThrottler { /* private fields */ }

Implements a probabilistic throttler based on observed failure rates.

This is an implementation of the Adaptive Throttling strategy described in Site Reliability Engineering book. The basic idea is to stochastically reject some of the retry attempts, with a rejection probability that increases as the number of failures increases, and decreases with the number of successful requests.

The rejection rate probability is defined by:

threshold = (requests - factor * accepts) / (requests + 1)
rejection_probability = max(0, threshold)

Where requests is the number of requests completed, and accepts is the number of requests accepted by the service, including requests that fail due to parameter validation, authorization checks, or any non-transient failures.

Note that accepts <= requests but the threshold value might be negative as factor can be higher than 1.0. In fact, the SRE book recommends using 2.0 as the initial factor.

Setting factor to lower values makes the algorithm reject retry attempts with higher probability. For example, setting it to zero would reject some retry attempts even if all requests have succeeded. Setting factor to higher values allows more retry attempts.

Implementations

impl AdaptiveThrottler

pub fn new(factor: f64) -> Result<Self>

Creates a new adaptive throttler with the given factor.

Parameters

• factor - a factor to adjust the relative weight of transient failures vs. accepted requests. See the struct definition for details.

Example

fn configure_throttler() -> Result<http_client::ClientConfig> {
    let throttler = AdaptiveThrottler::new(2.0)?;
    Ok(http_client::ClientConfig::default()
          .set_retry_throttler(throttler))
}

pub fn clamp(factor: f64) -> Self

Creates a new adaptive throttler clamping factor to a valid range.

Parameters

• factor - a factor to adjust the relative weight of transient failures vs. accepted requests. See the struct definition for details. Clamped to zero if the value is negative.

Example

fn configure_throttler() -> options::ClientConfig {
    let throttler = AdaptiveThrottler::clamp(2.0);
    options::ClientConfig::default()
          .set_retry_throttler(throttler)
}

Trait Implementations

impl Clone for AdaptiveThrottler

fn clone(&self) -> AdaptiveThrottler

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AdaptiveThrottler

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

Formats the value using the given formatter.

impl Default for AdaptiveThrottler

fn default() -> Self

Returns an AdaptiveThrottler initialized to the recommended values.

Example

fn configure_throttler() -> options::ClientConfig {
    let throttler = AdaptiveThrottler::default();
    options::ClientConfig::default()
          .set_retry_throttler(throttler)
}

impl RetryThrottler for AdaptiveThrottler

fn throttle_retry_attempt(&self) -> bool

Called by the retry loop before issuing a retry attempt. Returns true if the request should be throttled.

fn on_retry_failure(&mut self, flow: &RetryFlow)

Called by the retry loop after a retry failure.

fn on_success(&mut self)

Called by the retry loop when a RPC succeeds.