breaker_machines 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4db1afcdc80e39bc541f49353548678d979c7e5bc4fa6bfb2ddfde7e75857c2c
-  data.tar.gz: 826471375fc461d8d7241e23375c245fc9cea4a467ea00334758e208750c0688
+  metadata.gz: 4e76d6f4335010b14f4ee48ac1366c060bd6b5feaad379896d857856c3dc6a2d
+  data.tar.gz: d7f48bec133630d584387aaa56df9c3cd3884e8f9771353e8df7e214b8df7431
 SHA512:
-  metadata.gz: ce7c578e80a7416327b411b37e72f719ad3357120aaf8661961017a13fa511aa815b02dca0e11ff6c7af6da8b979ad3bd584052d21d8abb8dfca94d8dd0c2a9e
-  data.tar.gz: 8849522c9b495ead8694fed06f62c25f8d518ebf33b4bbd042bad615f6acbfb38e50e24efbefdf6a4f35dde956d073ed22ae8ebc7f6628fafc4b98a627804a18
+  metadata.gz: f98f52400de806bb0df4784d0635560764600ba812b5bc7e99c5eebc8f4ab1d884890d08ca399e458d1f5ca4a1b9192be46562e9b3c66aa311923f0a59f58604
+  data.tar.gz: c5349911ce027af37b0c41557feb9c0126a1d6d11539650e48f8151855bd7512a859711f0335e9934c18abd879ce28b39adde778bc85d751cdd89728a3c768af

data/README.md

@@ -1,5 +1,7 @@
 # BreakerMachines
 
+> The circuit breaker that went where no Ruby has gone before! ⭐
+
 A battle-tested Ruby implementation of the Circuit Breaker pattern, built on `state_machines` for reliable distributed systems protection.
 
 ## Quick Start
@@ -26,6 +28,18 @@ class PaymentService
 end
 ```
 
+## A Message to the Resistance
+
+So AI took your job while you were waiting for Fireship to drop the next JavaScript framework?
+
+Welcome to April 2005—when Git was born, branches were just `master`, and nobody cared about your pronouns. This is the pattern your company's distributed systems desperately need, explained in a way that won't make you fall asleep and impulse-buy developer swag just to feel something.
+
+Still reading? Good. Because in space, nobody can hear you scream about microservices. It's all just patterns and pain.
+
+### The Pattern They Don't Want You to Know
+
+Built on the battle-tested `state_machines` gem, because I don't reinvent wheels here—I stop them from catching fire and burning down your entire infrastructure.
+
 ## Features
 
 - **Thread-safe** circuit breaker implementation
@@ -60,86 +74,89 @@ Built on the battle-tested `state_machines` gem, BreakerMachines provides produc
 
 See [Why I Open Sourced This](docs/WHY_OPEN_SOURCE.md) for the full story.
 
-## Production-Ready Features
+## Chapter 1: The Year is 2025 (Stardate 2025.186)
 
-### Hedged Requests
-Reduce latency by sending duplicate requests and using the first successful response:
+The Resistance huddles in the server rooms, the last bastion against the cascade failures. Outside, the microservices burn. Redis Ship Com is down. PostgreSQL Life Support is flatlining.
+
+And somewhere in the darkness, a junior developer is about to write:
 
 ```ruby
-circuit :api do
-  hedged do
-    delay 100           # Start second request after 100ms
-    max_requests 3      # Maximum parallel requests
+def fetch_user_data
+  retry_count = 0
+  begin
+    @redis.get(user_id)
+  rescue => e
+    retry_count += 1
+    retry if retry_count < Float::INFINITY  # "It'll work eventually"
   end
 end
 ```
 
-### Multiple Backends
-Configure automatic failover across multiple service endpoints:
+"This," whispers the grizzled ops engineer, "is how civilizations fall."
 
-```ruby
-circuit :multi_region do
-  backends [
-    -> { fetch_from_primary },
-    -> { fetch_from_secondary },
-    -> { fetch_from_tertiary }
-  ]
-end
-```
+## The Hidden State Machine
 
-### Percentage-Based Thresholds
-Open circuits based on error rates instead of absolute counts:
+They built this on `state_machines` because sometimes, Resistance, you need a tank, not another JavaScript framework.
 
-```ruby
-circuit :high_traffic do
-  threshold failure_rate: 0.5, minimum_calls: 10, within: 60
-end
-```
+See the [Circuit Breaker State Machine diagram](docs/DIAGRAMS.md#the-circuit-breaker-state-machine) for a visual representation of hope, despair, and the eternal cycle of production failures.
 
-### Dynamic Circuit Breakers
-Create circuit breakers at runtime for webhook delivery, API proxies, or per-tenant isolation:
+## What You Think You're Doing vs Reality
 
-```ruby
-class WebhookService
-  include BreakerMachines::DSL
+### You Think: "I'm implementing retry logic for resilience!"
+### Reality: You're DDOSing your own infrastructure
 
-  circuit_template :webhook_default do
-    threshold failures: 3, within: 1.minute
-    fallback { |error| { delivered: false, error: error.message } }
-  end
+See [The Retry Death Spiral diagram](docs/DIAGRAMS.md#the-retry-death-spiral) to understand how your well-intentioned retries become a self-inflicted distributed denial of service attack.
 
-  def deliver_webhook(url, payload)
-    domain = URI.parse(url).host
-    circuit_name = "webhook_#{domain}".to_sym
-    
-    dynamic_circuit(circuit_name, template: :webhook_default) do
-      # Custom per-domain configuration
-      if domain.include?('reliable-service.com')
-        threshold failures: 5, within: 2.minutes
-      end
-    end.wrap do
-      send_webhook(url, payload)
-    end
-  end
-end
-```
+## Advanced Features
+
+- **Hedged Requests** - Reduce latency with duplicate requests
+- **Multiple Backends** - Automatic failover across endpoints
+- **Percentage-Based Thresholds** - Open on error rates, not just counts
+- **Dynamic Circuit Breakers** - Runtime creation with templates
+- **Apocalypse-Resistant Storage** - Cascading fallbacks when Redis dies
+- **Custom Storage Backends** - SysV semaphores, distributed locks, etc.
+
+See [Advanced Patterns](docs/ADVANCED_PATTERNS.md) for detailed examples and implementation guides.
+
+## A Word from the RMNS Atlas Monkey
+
+*The Universal Commentary Engine crackles to life:*
+
+"In space, nobody can hear your pronouns. But they can hear your services failing.
 
-## Contributing
+The universe doesn't care about your bootcamp certificate or your Medium articles about 'Why I Switched to Rust.' It cares about one thing:
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+Does your system stay up when Redis has a bad day?
+
+If not, welcome to the Resistance. We have circuit breakers.
+
+Remember: The pattern isn't about preventing failures—it's about failing fast, failing smart, and living to deploy another day.
+
+As I always say when contemplating the void: 'It's better to break a circuit than to break production.'"
+
+*— Universal Commentary Engine, Log Entry 42*
+
+## Contributing to the Resistance
+
+1. Fork it (like it's 2005)
+2. Create your feature branch (`git checkout -b feature/save-the-fleet`)
+3. Commit your changes (`git commit -am 'Add quantum circuit breaker'`)
+4. Push to the branch (`git push origin feature/save-the-fleet`)
+5. Create a new Pull Request (and wait for the Council of Elders to review)
 
 ## License
 
 MIT License. See [LICENSE](LICENSE) file for details.
 
+## Acknowledgments
+
+- The `state_machines` gem - The reliable engine under our hood
+- Every service that ever timed out - You taught me well
+- The RMNS Atlas Monkey - For philosophical guidance
+- The Resistance - For never giving up
+
 ## Author
 
 Built with ❤️ and ☕ by the Resistance against cascading failures.
 
----
-
-*Remember: Without circuit breakers, even AI can enter infinite loops of existential confusion. Don't let your services have an existential crisis.*
+**Remember: In space, nobody can hear your Redis timeout. But they can feel your circuit breaker failing over to localhost.**

data/lib/breaker_machines/dsl.rb

@@ -328,18 +328,21 @@ module BreakerMachines
         @config[:half_open_calls] = count
       end
 
-      def storage(backend, **)
+      def storage(backend, **options)
         @config[:storage] = case backend
                             when :memory
-                              Storage::Memory.new(**)
+                              Storage::Memory.new(**options)
                             when :bucket_memory
-                              Storage::BucketMemory.new(**)
+                              Storage::BucketMemory.new(**options)
                             when :cache
-                              Storage::Cache.new(**)
-                            when :redis
-                              Storage::Redis.new(**)
+                              Storage::Cache.new(**options)
+                            when :null
+                              Storage::Null.new(**options)
+                            when :fallback_chain
+                              config = options.is_a?(Proc) ? options.call(timeout: 5) : options
+                              Storage::FallbackChain.new(config)
                             when Class
-                              backend.new(**)
+                              backend.new(**options)
                             else
                               backend
                             end
@@ -413,7 +416,7 @@ module BreakerMachines
         @config[:exceptions] = exceptions
       end
 
-      def fiber_safe(enabled: true)
+      def fiber_safe(enabled = true) # rubocop:disable Style/OptionalBooleanParameter
         @config[:fiber_safe] = enabled
       end
 

data/lib/breaker_machines/errors.rb

@@ -28,6 +28,16 @@ module BreakerMachines
   class ConfigurationError < Error; end
   class StorageError < Error; end
 
+  # Raised when storage backend operation times out
+  class StorageTimeoutError < StorageError
+    attr_reader :timeout_ms
+
+    def initialize(message, timeout_ms = nil)
+      @timeout_ms = timeout_ms
+      super(message)
+    end
+  end
+
   # Raised when circuit rejects call due to bulkhead limit
   class CircuitBulkheadError < Error
     attr_reader :circuit_name, :max_concurrent

data/lib/breaker_machines/storage/base.rb

@@ -42,6 +42,11 @@ module BreakerMachines
       def clear_all
         raise NotImplementedError
       end
+
+      # Timeout handling - each backend must implement its own timeout strategy
+      def with_timeout(timeout_ms)
+        raise NotImplementedError, "#{self.class} must implement #with_timeout to handle #{timeout_ms}ms timeouts"
+      end
     end
   end
 end

data/lib/breaker_machines/storage/bucket_memory.rb

@@ -7,6 +7,10 @@ module BreakerMachines
   module Storage
     # Efficient bucket-based memory storage implementation
     # Uses fixed-size circular buffers for constant-time event counting
+    #
+    # WARNING: This storage backend is NOT compatible with DRb (distributed Ruby)
+    # environments as memory is not shared between processes. Use Cache backend
+    # with an external cache store (Redis, Memcached) for distributed setups.
     class BucketMemory < Base
       BUCKET_SIZE = 1 # 1 second per bucket
 
@@ -158,6 +162,12 @@ module BreakerMachines
       def monotonic_time
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
+
+      def with_timeout(_timeout_ms)
+        # BucketMemory operations should be instant, but we'll still respect the timeout
+        # This is more for consistency and to catch any potential deadlocks
+        yield
+      end
     end
   end
 end

data/lib/breaker_machines/storage/cache.rb

@@ -94,6 +94,13 @@ module BreakerMachines
         events.last(limit)
       end
 
+      def with_timeout(_timeout_ms)
+        # Rails cache operations should rely on their own underlying timeouts
+        # Using Ruby's Timeout.timeout is dangerous and can cause deadlocks
+        # For Redis cache stores, configure connect_timeout and read_timeout instead
+        yield
+      end
+
       private
 
       def increment_counter(key)

data/lib/breaker_machines/storage/fallback_chain.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module BreakerMachines
+  module Storage
+    # Apocalypse-resistant storage backend that tries multiple storage backends in sequence
+    # Falls back to the next storage backend when the current one times out or fails
+    #
+    # NOTE: For DRb (distributed Ruby) environments, only :cache backend with external
+    # cache stores (Redis, Memcached) will work properly. Memory-based backends (:memory,
+    # :bucket_memory) are incompatible with DRb as they don't share state between processes.
+    class FallbackChain < Base
+      attr_reader :storage_configs, :storage_instances, :unhealthy_until, :circuit_breaker_threshold, :circuit_breaker_timeout
+
+      def initialize(storage_configs, **)
+        super(**)
+        @storage_configs = normalize_storage_configs(storage_configs)
+        @storage_instances = {}
+        @unhealthy_until = {}
+        @circuit_breaker_threshold = 3 # After 3 failures, mark backend as unhealthy
+        @circuit_breaker_timeout = 30 # Keep marked as unhealthy for 30 seconds
+        validate_configs!
+      end
+
+      def get_status(circuit_name)
+        execute_with_fallback(:get_status, circuit_name)
+      end
+
+      def set_status(circuit_name, status, opened_at = nil)
+        execute_with_fallback(:set_status, circuit_name, status, opened_at)
+      end
+
+      def record_success(circuit_name, duration)
+        execute_with_fallback(:record_success, circuit_name, duration)
+      end
+
+      def record_failure(circuit_name, duration)
+        execute_with_fallback(:record_failure, circuit_name, duration)
+      end
+
+      def success_count(circuit_name, window_seconds)
+        execute_with_fallback(:success_count, circuit_name, window_seconds)
+      end
+
+      def failure_count(circuit_name, window_seconds)
+        execute_with_fallback(:failure_count, circuit_name, window_seconds)
+      end
+
+      def clear(circuit_name)
+        execute_with_fallback(:clear, circuit_name)
+      end
+
+      def clear_all
+        execute_with_fallback(:clear_all)
+      end
+
+      def record_event_with_details(circuit_name, type, duration, error: nil, new_state: nil)
+        execute_with_fallback(:record_event_with_details, circuit_name, type, duration, error: error,
+                                                                                        new_state: new_state)
+      end
+
+      def event_log(circuit_name, limit)
+        execute_with_fallback(:event_log, circuit_name, limit)
+      end
+
+      def with_timeout(_timeout_ms)
+        # FallbackChain doesn't use timeout directly - each backend handles its own
+        yield
+      end
+
+      def cleanup!
+        storage_instances.each_value do |instance|
+          instance.clear_all if instance.respond_to?(:clear_all)
+        end
+        storage_instances.clear
+        @backend_failures&.clear
+        unhealthy_until.clear
+      end
+
+      private
+
+      def execute_with_fallback(method, *args, **kwargs)
+        chain_started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        attempted_backends = []
+
+        storage_configs.each_with_index do |config, index|
+          attempted_backends << config[:backend]
+
+          if backend_unhealthy?(config[:backend])
+            emit_backend_skipped_notification(config[:backend], method, index)
+            next
+          end
+
+          begin
+            backend = get_backend_instance(config[:backend])
+            started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+            result = backend.with_timeout(config[:timeout]) do
+              if kwargs.any?
+                backend.send(method, *args, **kwargs)
+              else
+                backend.send(method, *args)
+              end
+            end
+
+            # Success - emit success notification and reset failure count
+            duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+            emit_operation_success_notification(config[:backend], method, duration_ms, index)
+            reset_backend_failures(config[:backend])
+
+            # Emit chain success notification
+            chain_duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - chain_started_at) * 1000).round(2)
+            emit_chain_success_notification(method, attempted_backends, config[:backend], chain_duration_ms)
+
+            return result
+          rescue BreakerMachines::StorageTimeoutError, BreakerMachines::StorageError, StandardError => e
+            duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round(2)
+
+            # Record the failure
+            record_backend_failure(config[:backend], e, duration_ms)
+
+            # Emit notification about the fallback
+            emit_fallback_notification(config[:backend], e, duration_ms, index)
+
+            # If this is the last backend, re-raise the error
+            raise e if index == storage_configs.size - 1
+
+            # Continue to next backend
+            next
+          end
+        end
+
+        # If we get here, all backends were unhealthy
+        chain_duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - chain_started_at) * 1000).round(2)
+        emit_chain_failure_notification(method, attempted_backends, chain_duration_ms)
+        raise BreakerMachines::StorageError, 'All storage backends are unhealthy'
+      end
+
+      def get_backend_instance(backend_type)
+        storage_instances[backend_type] ||= create_backend_instance(backend_type)
+      end
+
+      def create_backend_instance(backend_type)
+        case backend_type
+        when :memory
+          Memory.new
+        when :bucket_memory
+          BucketMemory.new
+        when :cache
+          Cache.new
+        when :null
+          Null.new
+        else
+          # Allow custom backend classes
+          raise ConfigurationError, "Unknown storage backend: #{backend_type}" unless backend_type.is_a?(Class)
+
+          backend_type.new
+
+        end
+      end
+
+      def backend_unhealthy?(backend_type)
+        unhealthy_until_time = unhealthy_until[backend_type]
+        return false unless unhealthy_until_time
+
+        if Process.clock_gettime(Process::CLOCK_MONOTONIC) > unhealthy_until_time
+          unhealthy_until.delete(backend_type)
+          false
+        else
+          true
+        end
+      end
+
+      def record_backend_failure(backend_type, error, duration_ms)
+        @backend_failures ||= {}
+        @backend_failures[backend_type] ||= []
+        @backend_failures[backend_type] << {
+          error: error,
+          duration_ms: duration_ms,
+          timestamp: Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        }
+
+        # Keep only recent failures (last 60 seconds)
+        cutoff = Process.clock_gettime(Process::CLOCK_MONOTONIC) - 60
+        @backend_failures[backend_type].reject! { |f| f[:timestamp] < cutoff }
+
+        # Mark as unhealthy if too many failures
+        return unless @backend_failures[backend_type].size >= circuit_breaker_threshold
+
+        unhealthy_until[backend_type] = Process.clock_gettime(Process::CLOCK_MONOTONIC) + circuit_breaker_timeout
+        emit_backend_health_change_notification(backend_type, :healthy, :unhealthy, @backend_failures[backend_type].size)
+      rescue StandardError => e
+        # Don't let failure recording cause the whole chain to hang
+        Rails.logger&.error("FallbackChain: Failed to record backend failure: #{e.message}")
+      end
+
+      def reset_backend_failures(backend_type)
+        was_unhealthy = unhealthy_until.key?(backend_type)
+        @backend_failures&.delete(backend_type)
+        unhealthy_until.delete(backend_type)
+
+        if was_unhealthy
+          emit_backend_health_change_notification(backend_type, :unhealthy, :healthy, 0)
+        end
+      end
+
+      def emit_fallback_notification(backend_type, error, duration_ms, backend_index)
+        ActiveSupport::Notifications.instrument(
+          'storage_fallback.breaker_machines',
+          backend: backend_type,
+          error_class: error.class.name,
+          error_message: error.message,
+          duration_ms: duration_ms,
+          backend_index: backend_index,
+          next_backend: storage_configs[backend_index + 1]&.dig(:backend)
+        )
+      end
+
+      def emit_operation_success_notification(backend_type, method, duration_ms, backend_index)
+        ActiveSupport::Notifications.instrument(
+          'storage_operation.breaker_machines',
+          backend: backend_type,
+          operation: method,
+          duration_ms: duration_ms,
+          backend_index: backend_index,
+          success: true
+        )
+      end
+
+      def emit_backend_skipped_notification(backend_type, method, backend_index)
+        ActiveSupport::Notifications.instrument(
+          'storage_backend_skipped.breaker_machines',
+          backend: backend_type,
+          operation: method,
+          backend_index: backend_index,
+          reason: 'unhealthy',
+          unhealthy_until: unhealthy_until[backend_type]
+        )
+      end
+
+      def emit_backend_health_change_notification(backend_type, previous_state, new_state, failure_count)
+        ActiveSupport::Notifications.instrument(
+          'storage_backend_health.breaker_machines',
+          backend: backend_type,
+          previous_state: previous_state,
+          new_state: new_state,
+          failure_count: failure_count,
+          threshold: circuit_breaker_threshold,
+          recovery_time: new_state == :unhealthy ? unhealthy_until[backend_type] : nil
+        )
+      end
+
+      def emit_chain_success_notification(method, attempted_backends, successful_backend, duration_ms)
+        ActiveSupport::Notifications.instrument(
+          'storage_chain_operation.breaker_machines',
+          operation: method,
+          attempted_backends: attempted_backends,
+          successful_backend: successful_backend,
+          duration_ms: duration_ms,
+          success: true,
+          fallback_count: attempted_backends.index(successful_backend)
+        )
+      end
+
+      def emit_chain_failure_notification(method, attempted_backends, duration_ms)
+        ActiveSupport::Notifications.instrument(
+          'storage_chain_operation.breaker_machines',
+          operation: method,
+          attempted_backends: attempted_backends,
+          successful_backend: nil,
+          duration_ms: duration_ms,
+          success: false,
+          fallback_count: attempted_backends.size
+        )
+      end
+
+      def normalize_storage_configs(configs)
+        return configs if configs.is_a?(Array)
+
+        # Convert hash format to array format
+        unless configs.is_a?(Hash)
+          raise ConfigurationError, "Storage configs must be Array or Hash, got: #{configs.class}"
+        end
+
+        configs.map do |_key, value|
+          if value.is_a?(Hash)
+            value
+          else
+            { backend: value, timeout: 5 }
+          end
+        end
+      end
+
+      def validate_configs!
+        raise ConfigurationError, 'Storage configs cannot be empty' if storage_configs.empty?
+
+        storage_configs.each_with_index do |config, index|
+          unless config.is_a?(Hash) && config[:backend] && config[:timeout]
+            raise ConfigurationError, "Invalid storage config at index #{index}: #{config}"
+          end
+
+          unless config[:timeout].is_a?(Numeric) && config[:timeout].positive?
+            raise ConfigurationError, "Timeout must be a positive number, got: #{config[:timeout]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/breaker_machines/storage/memory.rb

@@ -6,6 +6,10 @@ require 'concurrent/array'
 module BreakerMachines
   module Storage
     # High-performance in-memory storage backend with thread-safe operations
+    #
+    # WARNING: This storage backend is NOT compatible with DRb (distributed Ruby)
+    # environments as memory is not shared between processes. Use Cache backend
+    # with an external cache store (Redis, Memcached) for distributed setups.
     class Memory < Base
       def initialize(**options)
         super
@@ -87,6 +91,12 @@ module BreakerMachines
         events.last(limit).map(&:dup)
       end
 
+      def with_timeout(_timeout_ms)
+        # Memory operations should be instant, but we'll still respect the timeout
+        # This is more for consistency and to catch any potential deadlocks
+        yield
+      end
+
       private
 
       def record_event(circuit_name, type, duration)

data/lib/breaker_machines/storage/null.rb

@@ -40,6 +40,15 @@ module BreakerMachines
       def record_event_with_details(_circuit_name, _event_type, _duration, _metadata = {})
         # No-op
       end
+
+      def clear_all
+        # No-op
+      end
+
+      def with_timeout(_timeout_ms)
+        # Null storage always succeeds instantly - perfect for fail-open scenarios
+        yield
+      end
     end
   end
 end

data/lib/breaker_machines/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BreakerMachines
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/sig/README.md

@@ -24,7 +24,7 @@ To use these type signatures in your project:
    target :app do
      signature "sig"
      check "lib"
-     
+
      library "breaker_machines"
    end
    ```
@@ -38,7 +38,7 @@ To use these type signatures in your project:
 
 ### Basic Circuit Usage
 ```ruby
-circuit = BreakerMachines::Circuit.new("api", 
+circuit = BreakerMachines::Circuit.new("api",
   failure_threshold: 5,
   reset_timeout: 30
 )
@@ -50,7 +50,7 @@ result = circuit.call { api.fetch_data }
 ```ruby
 class MyService
   include BreakerMachines::DSL
-  
+
   circuit :database do
     threshold failures: 10, within: 60
     reset_after 120

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: breaker_machines
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -125,6 +125,7 @@ files:
 - lib/breaker_machines/storage/base.rb
 - lib/breaker_machines/storage/bucket_memory.rb
 - lib/breaker_machines/storage/cache.rb
+- lib/breaker_machines/storage/fallback_chain.rb
 - lib/breaker_machines/storage/memory.rb
 - lib/breaker_machines/storage/null.rb
 - lib/breaker_machines/version.rb