Struct CircuitBreaker 

pub struct CircuitBreaker { /* private fields */ }

Circuit breaker for preventing cascading failures.

The circuit breaker monitors request success/failure patterns and automatically blocks requests to failing endpoints, allowing the system to recover.

Thread Safety

This implementation uses atomic operations for all state management, making it safe to use from multiple threads without external locking.

Example

use ccxt_core::circuit_breaker::{CircuitBreaker, CircuitBreakerConfig};

let breaker = CircuitBreaker::new(CircuitBreakerConfig::default());

// Before making a request
if let Err(e) = breaker.allow_request() {
    // Circuit is open, handle the error
    println!("Circuit is open: {}", e);
} else {
    // Make the request
    let success = true; // result of the request
    if success {
        breaker.record_success();
    } else {
        breaker.record_failure();
    }
}

Implementations

impl CircuitBreaker

pub fn new(config: CircuitBreakerConfig) -> CircuitBreaker

Creates a new circuit breaker with the given configuration.

Arguments

• config - Circuit breaker configuration

Example

use ccxt_core::circuit_breaker::{CircuitBreaker, CircuitBreakerConfig};

let breaker = CircuitBreaker::new(CircuitBreakerConfig::default());

pub fn with_events( config: CircuitBreakerConfig, event_tx: UnboundedSender<CircuitBreakerEvent>, ) -> CircuitBreaker

Creates a new circuit breaker with an event channel for observability.

Arguments

• config - Circuit breaker configuration
• event_tx - Channel sender for circuit breaker events

Example

use ccxt_core::circuit_breaker::{CircuitBreaker, CircuitBreakerConfig, CircuitBreakerEvent};
use tokio::sync::mpsc;

let (tx, mut rx) = mpsc::unbounded_channel::<CircuitBreakerEvent>();
let breaker = CircuitBreaker::with_events(CircuitBreakerConfig::default(), tx);

// Events will be sent to the channel when state changes occur

pub fn allow_request(&self) -> Result<(), Error>

Checks if a request should be allowed.

Returns

Returns Ok(()) if the request is allowed. Returns Err(Error::ResourceExhausted) if the circuit is open.

State Transitions

• Closed: Always allows requests
• Open: Checks if reset_timeout has elapsed; if so, transitions to HalfOpen
• HalfOpen: Allows requests (for testing recovery)

Example

use ccxt_core::circuit_breaker::{CircuitBreaker, CircuitBreakerConfig};

let breaker = CircuitBreaker::new(CircuitBreakerConfig::default());

match breaker.allow_request() {
    Ok(()) => println!("Request allowed"),
    Err(e) => println!("Request blocked: {}", e),
}

pub fn record_success(&self)

Records a successful request.

State Transitions

• Closed: Resets the failure count to 0
• HalfOpen: Increments success count; if it reaches success_threshold, transitions to Closed
• Open: No effect

Example

use ccxt_core::circuit_breaker::{CircuitBreaker, CircuitBreakerConfig};

let breaker = CircuitBreaker::new(CircuitBreakerConfig::default());

// After a successful request
breaker.record_success();

pub fn record_failure(&self)

Records a failed request.

State Transitions

• Closed: Increments failure count; if it reaches failure_threshold, transitions to Open
• HalfOpen: Transitions immediately to Open (test request failed)
• Open: No effect

Example

use ccxt_core::circuit_breaker::{CircuitBreaker, CircuitBreakerConfig};

let breaker = CircuitBreaker::new(CircuitBreakerConfig::default());

// After a failed request
breaker.record_failure();

pub fn state(&self) -> CircuitState

Returns the current state of the circuit breaker.

Example

use ccxt_core::circuit_breaker::{CircuitBreaker, CircuitBreakerConfig, CircuitState};

let breaker = CircuitBreaker::new(CircuitBreakerConfig::default());
assert_eq!(breaker.state(), CircuitState::Closed);

pub fn failure_count(&self) -> u32

Returns the current failure count.

This is primarily useful for monitoring and debugging.

pub fn success_count(&self) -> u32

Returns the current success count (in HalfOpen state).

This is primarily useful for monitoring and debugging.

pub fn config(&self) -> &CircuitBreakerConfig

Returns a reference to the configuration.

pub fn reset(&self)

Resets the circuit breaker to its initial state (Closed).

This can be useful for testing or manual intervention.

Example

use ccxt_core::circuit_breaker::{CircuitBreaker, CircuitBreakerConfig};

let breaker = CircuitBreaker::new(CircuitBreakerConfig::default());
// ... some operations that opened the circuit ...
breaker.reset();
// Circuit is now Closed again

Trait Implementations

impl Debug for CircuitBreaker

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

Formats the value using the given formatter.