breaker_machines 0.1.0 → 0.2.0

data/lib/breaker_machines/storage/cache.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module BreakerMachines
+  module Storage
+    # Storage adapter for ActiveSupport::Cache
+    # Works with any Rails cache store (Redis, Memcached, Memory, etc.)
+    class Cache < Base
+      def initialize(cache_store: Rails.cache, **options)
+        super(**options)
+        @cache = cache_store
+        @prefix = options[:prefix] || 'breaker_machines'
+        @expires_in = options[:expires_in] || 300 # 5 minutes default
+      end
+
+      def get_status(circuit_name)
+        data = @cache.read(status_key(circuit_name))
+        return nil unless data
+
+        {
+          status: data[:status].to_sym,
+          opened_at: data[:opened_at]
+        }
+      end
+
+      def set_status(circuit_name, status, opened_at = nil)
+        @cache.write(
+          status_key(circuit_name),
+          {
+            status: status,
+            opened_at: opened_at,
+            updated_at: monotonic_time
+          },
+          expires_in: @expires_in
+        )
+      end
+
+      def record_success(circuit_name, _duration)
+        increment_counter(success_key(circuit_name))
+      end
+
+      def record_failure(circuit_name, _duration)
+        increment_counter(failure_key(circuit_name))
+      end
+
+      def success_count(circuit_name, window_seconds)
+        get_window_count(success_key(circuit_name), window_seconds)
+      end
+
+      def failure_count(circuit_name, window_seconds)
+        get_window_count(failure_key(circuit_name), window_seconds)
+      end
+
+      def clear(circuit_name)
+        @cache.delete(status_key(circuit_name))
+        @cache.delete(success_key(circuit_name))
+        @cache.delete(failure_key(circuit_name))
+        @cache.delete(events_key(circuit_name))
+      end
+
+      def clear_all
+        # Clear all circuit data by pattern if cache supports it
+        if @cache.respond_to?(:delete_matched)
+          @cache.delete_matched("#{@prefix}:*")
+        else
+          # Fallback: can't efficiently clear all without pattern support
+          BreakerMachines.logger&.warn(
+            "[BreakerMachines] Cache store doesn't support delete_matched. " \
+            'Individual circuit data must be cleared manually.'
+          )
+        end
+      end
+
+      def record_event_with_details(circuit_name, type, duration, error: nil, new_state: nil)
+        events = @cache.fetch(events_key(circuit_name)) { [] }
+
+        event = {
+          type: type,
+          timestamp: monotonic_time,
+          duration_ms: (duration * 1000).round(2)
+        }
+
+        event[:error_class] = error.class.name if error
+        event[:error_message] = error.message if error
+        event[:new_state] = new_state if new_state
+
+        events << event
+        events.shift while events.size > (@max_events || 100)
+
+        @cache.write(events_key(circuit_name), events, expires_in: @expires_in)
+      end
+
+      def event_log(circuit_name, limit)
+        events = @cache.read(events_key(circuit_name)) || []
+        events.last(limit)
+      end
+
+      private
+
+      def increment_counter(key)
+        # Use increment if available, otherwise fetch-and-update
+        if @cache.respond_to?(:increment)
+          @cache.increment(key, 1, expires_in: @expires_in)
+        else
+          # Fallback for caches without atomic increment
+          current = @cache.fetch(key) { {} }
+          current[current_bucket] = (current[current_bucket] || 0) + 1
+          prune_old_buckets(current)
+          @cache.write(key, current, expires_in: @expires_in)
+        end
+      end
+
+      def get_window_count(key, window_seconds)
+        if @cache.respond_to?(:increment)
+          # For simple counter-based caches, we can't get windowed counts
+          # Would need to implement bucketing similar to fallback
+          @cache.read(key) || 0
+        else
+          # Bucket-based counting for accurate windows
+          buckets = @cache.read(key) || {}
+          current_time = current_bucket
+
+          total = 0
+          window_seconds.times do |i|
+            bucket_key = current_time - i
+            total += buckets[bucket_key] || 0
+          end
+
+          total
+        end
+      end
+
+      def prune_old_buckets(buckets)
+        cutoff = current_bucket - 300 # Keep 5 minutes of data
+        buckets.delete_if { |time, _| time < cutoff }
+      end
+
+      def current_bucket
+        Time.now.to_i
+      end
+
+      def status_key(circuit_name)
+        "#{@prefix}:#{circuit_name}:status"
+      end
+
+      def success_key(circuit_name)
+        "#{@prefix}:#{circuit_name}:successes"
+      end
+
+      def failure_key(circuit_name)
+        "#{@prefix}:#{circuit_name}:failures"
+      end
+
+      def events_key(circuit_name)
+        "#{@prefix}:#{circuit_name}:events"
+      end
+
+      def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/breaker_machines/version.rb

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

data/lib/breaker_machines.rb

@@ -9,6 +9,8 @@ loader = Zeitwerk::Loader.for_gem
 loader.inflector.inflect('dsl' => 'DSL')
 loader.ignore("#{__dir__}/breaker_machines/errors.rb")
 loader.ignore("#{__dir__}/breaker_machines/console.rb")
+loader.ignore("#{__dir__}/breaker_machines/async_support.rb")
+loader.ignore("#{__dir__}/breaker_machines/hedged_async_support.rb")
 loader.setup
 
 # BreakerMachines provides a thread-safe implementation of the Circuit Breaker pattern
@@ -25,7 +27,7 @@ module BreakerMachines
 
   config_accessor :default_storage, default: :bucket_memory
   config_accessor :default_timeout, default: nil
-  config_accessor :default_reset_timeout, default: 60
+  config_accessor :default_reset_timeout, default: 60.seconds
   config_accessor :default_failure_threshold, default: 5
   config_accessor :log_events, default: true
   config_accessor :fiber_safe, default: false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: breaker_machines
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -108,6 +108,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/breaker_machines.rb
+- lib/breaker_machines/async_support.rb
 - lib/breaker_machines/circuit.rb
 - lib/breaker_machines/circuit/callbacks.rb
 - lib/breaker_machines/circuit/configuration.rb
@@ -117,10 +118,13 @@ files:
 - lib/breaker_machines/console.rb
 - lib/breaker_machines/dsl.rb
 - lib/breaker_machines/errors.rb
+- lib/breaker_machines/hedged_async_support.rb
+- lib/breaker_machines/hedged_execution.rb
 - lib/breaker_machines/registry.rb
 - lib/breaker_machines/storage.rb
 - lib/breaker_machines/storage/base.rb
 - lib/breaker_machines/storage/bucket_memory.rb
+- lib/breaker_machines/storage/cache.rb
 - lib/breaker_machines/storage/memory.rb
 - lib/breaker_machines/storage/null.rb
 - lib/breaker_machines/version.rb