Struct CircuitBreakerPolicy 

pub struct CircuitBreakerPolicy {
    pub enabled: bool,
    pub failure_threshold: u32,
    pub cooldown_ms: u64,
    pub half_open_max_calls: u32,
}

Per-origin circuit-breaker policy (#963). Field-level validation lives at config-resolve time (crates/common/src/config/mod.rs::resolve_circuit_breaker); this struct just carries the values.

The breaker fronts each origin’s pull-through retry loop. After failure_threshold consecutive transient/origin-unavailable failures it trips OPEN and fast-fails every subsequent miss for cooldown_ms (no retry/backoff incurred). Once the cooldown elapses it goes HALF-OPEN and admits up to half_open_max_calls trial pulls; a trial success closes the breaker, a trial failure re-opens it.

Permanent per-object failures (HTTP 404 → NotFound, other 4xx / decode / cap breaches → Permanent) deliberately do not count toward the threshold: a missing object is not an origin outage, and tripping the breaker on 404s would shed load for content the origin is perfectly able to serve.

enabled == false (or failure_threshold == 0) disables the breaker entirely — every miss runs the full retry/backoff loop regardless of origin health.

Fields

enabled: bool

Master switch. false disables the breaker, so every cache miss runs the full retry/backoff loop. The thresholds below are ignored while disabled.

failure_threshold: u32

Consecutive transient/origin-unavailable failures that trip the breaker from CLOSED to OPEN. 0 is treated as “disabled” (same as enabled = false) so an operator can’t accidentally configure a breaker that trips on the very first blip. Defaults to 5: high enough to ride out a single flaky request, low enough that a genuine outage trips within a handful of misses.

cooldown_ms: u64

How long the breaker stays OPEN (fast-failing every miss) before transitioning to HALF-OPEN to probe for recovery, in milliseconds. Defaults to 30_000 (30s): long enough to shed the retry-storm during a real outage, short enough that a recovered origin resumes serving promptly.

half_open_max_calls: u32

Maximum number of trial pulls admitted while HALF-OPEN. The first half_open_max_calls misses after the cooldown are allowed through (each running its normal retry budget); further misses fast-fail until a trial resolves. A single trial success closes the breaker; a single trial failure re-opens it (resetting the cooldown). Defaults to 1: the standard half-open single-probe recipe — admit exactly one request to test the waters without re-flooding a still-sick origin.

Implementations

impl CircuitBreakerPolicy

pub const fn disabled() -> CircuitBreakerPolicy

A policy with the breaker disabled — every miss runs the full retry/backoff loop. Useful in tests and for operators who want to opt out.

pub const fn is_active(&self) -> bool

True when the breaker is active: explicitly enabled AND configured with a non-zero failure threshold. A failure_threshold == 0 collapses to disabled regardless of enabled so the breaker can never trip on the first failure.

Trait Implementations

impl Clone for CircuitBreakerPolicy

fn clone(&self) -> CircuitBreakerPolicy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CircuitBreakerPolicy

impl Debug for CircuitBreakerPolicy

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

Formats the value using the given formatter.

impl Default for CircuitBreakerPolicy

fn default() -> CircuitBreakerPolicy

Defaults: breaker on, trips after 5 consecutive origin-unavailable failures, stays OPEN for 30s, then admits 1 half-open trial. See the field docs for per-knob rationale.

impl<'de> Deserialize<'de> for CircuitBreakerPolicy

where CircuitBreakerPolicy: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<CircuitBreakerPolicy, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for CircuitBreakerPolicy

impl PartialEq for CircuitBreakerPolicy

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for CircuitBreakerPolicy

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CircuitBreakerPolicy