dmexe / failsafe-rs

A circuit breaker implementation for rust

Failsafe

A circuit breaker implementation which used to detect failures and encapsulates the logic of preventing a failure from constantly recurring, during maintenance, temporary external system failure or unexpected system difficulties.

• https://martinfowler.com/bliki/CircuitBreaker.html
• Read documentation

Features

• Working with both Fn() -> Result and Future (optional via default futures-support feature).
• Backoff strategies: constant, exponential, equal_jittered, full_jittered
• Failure detection policies: consecutive_failures, success_rate_over_time_window
• Minimum rust version: 1.63

Usage

Add this to your Cargo.toml:

failsafe = "1.3.0"

Example

Using default backoff strategy and failure accrual policy.

use failsafe::{Config, CircuitBreaker, Error};

// A function that sometimes failed.
fn dangerous_call() -> Result<(), ()> {
  if thread_rng().gen_range(0, 2) == 0 {
    return Err(())
  }
  Ok(())
}

// Create a circuit breaker which configured by reasonable default backoff and
// failure accrual policy.
let circuit_breaker = Config::new().build();

// Call the function in a loop, after some iterations the circuit breaker will
// be in a open state and reject next calls.
for n in 0..100 {
  match circuit_breaker.call(|| dangerous_call()) {
    Err(Error::Inner(_)) => {
      eprintln!("{}: fail", n);
    },
    Err(Error::Rejected) => {
       eprintln!("{}: rejected", n);
       break;
    },
    _ => {}
  }
}

Or configure custom backoff and policy:

use std::time::Duration;
use failsafe::{backoff, failure_policy, CircuitBreaker};

// Create an exponential growth backoff which starts from 10s and ends with 60s.
let backoff = backoff::exponential(Duration::from_secs(10), Duration::from_secs(60));

// Create a policy which failed when three consecutive failures were made.
let policy = failure_policy::consecutive_failures(3, backoff);

// Creates a circuit breaker with given policy.
let circuit_breaker = Config::new()
  .failure_policy(policy)
  .build();

failsafe-rs's Issues

Consider Expanding?

Have you considered expanding this library to add other distributed reliability tools, like BulkHeads, RateLimiters, and Retry(s)? It would probably require a serious re-org to move all the stuff in the base module into a more reasonable place, but it also would be nice to have a Rust alternative to r4j or Hystrix.

Edit: I'd be willing to help, but I don't want to sink any time into it if you're not interested in taking the library in that direction and/or supporting it.

Bump version number

Hey,

This is commit: d8c6b73#diff-e6580009c99953c9f2fe050c1acef12a is in my opinion sufficent to bump the version number

This will solve some resolution panics that I have received thanks

Consider renaming `exponential_backoff` to `binary_exponential_backoff`

License?

Does this project have a license? Maybe MIT License?

Example for sharing StateMachine

Thank you very much for this crate!
I have one question, could you please add an example how the circuit breaker is shared via multiple functions... eg

use failsafe::{CircuitBreaker, Config, Error};
use rand::{thread_rng, Rng};

fn dangerous_call() -> Result<(), ()> {
    if thread_rng().gen_range(0, 2) == 0 {
        return Err(());
    }
    Ok(())
}

fn caller(circuit_breaker: XXXX) {
    for n in 0..100 {
        match circuit_breaker.call(|| dangerous_call()) {
            Err(Error::Inner(_)) => {
                eprintln!("{}: fail", n);
            }
            Err(Error::Rejected) => {
                eprintln!("{}: rejected", n);
                break;
            }
            _ => {}
        }
    }
}

fn main() {
    caller(Config::new().build());
}

I have no clue what the type XXXX would be. Maybe others have the same issue.
Thanks a lot.