seatbelt 0.4.2

Resilience and recovery mechanisms for fallible operations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

use std::fmt::Debug;
use std::time::Duration;

use crate::breaker::{ExecutionResult, HealthInfo, HealthMetricsBuilder};

pub(super) mod probing;

#[cfg(any(feature = "metrics", feature = "logs", test))]
#[derive(Debug, Copy, Clone)]
pub(crate) enum CircuitState {
    Closed,
    Open,
    HalfOpen,
}

#[cfg(any(feature = "metrics", feature = "logs", test))]
impl CircuitState {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Closed => "closed",
            Self::Open => "open",
            Self::HalfOpen => "half_open",
        }
    }
}

/// Result of attempting to enter the circuit.
#[derive(Debug, Clone)]
pub(crate) enum EnterCircuitResult {
    /// The operation is allowed to proceed.
    ///
    /// The `probe` indicates that this is a test operation used to evaluate whether
    /// the circuit can be closed again.
    Accepted { mode: ExecutionMode },

    /// Operation is rejected due to open circuit.
    Rejected,
}

#[derive(Debug, Clone)]
pub(crate) enum ExitCircuitResult {
    /// The state remains unchanged.
    Unchanged,

    /// Circuit transitioned to Open state.
    Opened(HealthInfo),

    /// Circuit re-transitioned to Open state due to a failure in Half-Open state.
    Reopened,

    /// Circuit transitioned back to Closed state.
    Closed(Stats),
}

/// Configuration options for the circuit breaker engine.
#[derive(Debug, Clone)]
pub(crate) struct EngineOptions {
    pub break_duration: Duration,
    pub health_metrics_builder: HealthMetricsBuilder,
    pub probes: probing::ProbesOptions,
}

/// Determines the mode of execution for an operation.
#[derive(Debug, Clone, Copy, PartialEq)]
pub(crate) enum ExecutionMode {
    /// Regular operation.
    Normal,

    /// A probe operation to test the health of the underlying service.
    Probe,
}

// Type alias for the default engine with telemetry.
pub type Engine = EngineTelemetry<EngineCore>;

/// Trait defining the behavior of a circuit breaker engine.
pub(crate) trait CircuitEngine: Debug + Send + Sync + 'static {
    fn enter(&self) -> EnterCircuitResult;

    fn exit(&self, result: ExecutionResult, mode: ExecutionMode) -> ExitCircuitResult;
}

mod engine_core;
pub(crate) use engine_core::*;

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod engine_fake;
#[cfg(test)]
pub(crate) use engine_fake::*;

mod engine_telemetry;
pub(crate) use engine_telemetry::*;

mod engines;
pub(crate) use engines::*;

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_circuit_state_as_str() {
        assert_eq!(CircuitState::Closed.as_str(), "closed");
        assert_eq!(CircuitState::Open.as_str(), "open");
        assert_eq!(CircuitState::HalfOpen.as_str(), "half_open");
    }
}