fuse
A robust circuit breaker library for Erlang applications to prevent cascading failures and improve system resilience.
What is fuse?
Fuse is an Erlang/OTP application that implements the circuit breaker pattern, a fault-tolerance mechanism for distributed systems. It prevents cascading failures by detecting errors in dependent services and temporarily blocking requests, allowing systems to degrade gracefully and auto-heal when issues are resolved.
Erlang/Elixir developers building distributed systems with long dependency chains, such as microservices or layered applications, where service failures could cascade and cause latency or resource waste.
Developers choose Fuse for its correctness and reliability, backed by extensive property-based testing with Erlang QuickCheck to eliminate subtle concurrency and timing errors. It offers high performance with sub-microsecond overhead, configurable fuse types, and integration with monitoring systems like Prometheus.
Overview
A Circuit Breaker for Erlang
Use Cases
Best For
- Preventing cascading failures in Erlang-based microservices architectures.
- Adding fault tolerance to distributed systems with long dependency chains (e.g., app_A → app_B → app_C).
- Testing system robustness through fault injection fuses that simulate failures at a specified rate.
- Monitoring service health with built-in stats plugins for ETS, Folsom, Exometer, or Prometheus.
- Handling administrative overrides in production with manual circuit disable/enable commands.
- Reacting to fuse state changes in real-time via an event handler system for blown or ok events.
Not Ideal For
- Systems requiring per-error-type circuit breaking with different thresholds for various failure modes.
- Projects that need integrated process supervision and automatic restarts on failures (like breaky offers).
- Environments where strict linearizability is critical and async_dirty context races are unacceptable.
- Non-Erlang applications, as Fuse is tightly coupled to Erlang/OTP and not portable to other runtimes.
Pros & Cons
Pros
Extensive Erlang QuickCheck testing eliminates subtle concurrency and timing errors, ensuring high reliability and correctness as part of a system's error kernel.
Sub-microsecond overhead for fuse queries enables millions of operations per second with minimal latency impact, as benchmarked on typical hardware.
Supports standard fuses with configurable thresholds and fault injection fuses to simulate failures at a specified rate, aiding in robustness testing.
Built-in stats plugins for ETS, Folsom, Exometer, and Prometheus, plus Erlang alarm handler integration with hysteresis for comprehensive system oversight.
Cons
Using the async_dirty context can lead to rare race conditions where parallel processes observe inconsistent fuse states, breaking linearizability and requiring careful handling.
Designed exclusively for Erlang/OTP, making it unsuitable for projects in other languages or ecosystems without complex interoperability workarounds.
Requires precise setup of fuse strategies, refresh policies, and stats plugins, which can be error-prone and daunting for developers new to circuit breakers.
Frequently Asked Questions
Related Projects
flowComputational parallel flows on top of GenStage
witchcraftMonads and other dark magic for Elixir
machineryElixir State machine thin layer for structs
matrexA blazing fast matrix library for Elixir/Erlang with C implementation using CBLAS.
Found a gem we're missing?
Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.