breaker_machines 0.12.0 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 302ad7f4383ff797f0f9bf89c4da1252f27f33ebcfab3cc7c3c114ba32afe5e0
-  data.tar.gz: 6fc626f0001941fe023d02417c384673b4df74c3cbbb82c28c8a1e932992ba00
+  metadata.gz: dab65770123fb6626a9112608ddeb784b1f623c6dd61ba59bd4f2094f8c73bb4
+  data.tar.gz: 572686fc3febc21058ea20c300667d09b466d427c0bcab98af4230e5e14c7ee3
 SHA512:
-  metadata.gz: b84a777ed7f9bb88bca15ec3935193123bcdf47e9642d2a4ffe4c8de35ea9dcd1d335717922739675f144915815e10e2adc638bb6bb747bc2f0ca35e7968211d
-  data.tar.gz: 91e832c67256d91f61692fe7f7ca7b006fef2752560b98a95f9ac3d0169a4af5f9fe4d1e8ebb8d794f6d9dbbe72a2f4e7e71b7b3b7d1d4b1c1de115d96d3707d
+  metadata.gz: ba432f7aeda81bd88dd93ea8d1c0cb1c843cbc964bc3a31c6baf1359b4fb0a2c4873cd0e5d19ed0543ef5f3ba728f7e2de78a022f395abec3164465f8d562169
+  data.tar.gz: 43f4c0da0445a1c7e91a9a1ba24e8892d4ba10cf1891ab75c44704834a1026b20e23fa5830c23029b3dee4a04ca9bba51c2319f069b0b92bbf7abd910a445ad1

data/lib/breaker_machines/cascading_circuit.rb

@@ -95,17 +95,9 @@ module BreakerMachines
       @cascade_triggered_at.value = BreakerMachines.monotonic_time
 
       @dependent_circuits.each do |circuit_name|
-        # First try to find circuit in registry
-        circuit = BreakerMachines.registry.find(circuit_name)
-
-        # If not found and we have an owner, try to get it from the owner
-        if !circuit && @config[:owner]
-          owner = @config[:owner]
-          # Handle WeakRef if present
-          owner = owner.__getobj__ if owner.is_a?(WeakRef)
-
-          circuit = owner.circuit(circuit_name) if owner.respond_to?(:circuit)
-        end
+        # Resolve via registry, falling back to the owner (inherited from
+        # CoordinatedStateManagement).
+        circuit = find_dependent_circuit(circuit_name)
 
         next unless circuit
         next unless circuit.closed? || circuit.half_open?

data/lib/breaker_machines/circuit/async_state_management.rb

@@ -14,11 +14,6 @@ module BreakerMachines
         # - Fiber-safe execution
         # - Concurrent transition handling
         state_machine :status, initial: :closed, async: true do
-          event :trip do
-            transition closed: :open
-            transition half_open: :open
-          end
-
           event :attempt_recovery do
             transition open: :half_open
           end
@@ -28,36 +23,7 @@ module BreakerMachines
             transition closed: :closed
           end
 
-          event :force_open do
-            transition any => :open
-          end
-
-          event :force_close do
-            transition any => :closed
-          end
-
-          event :hard_reset do
-            transition any => :closed
-          end
-
-          before_transition on: :hard_reset do |circuit|
-            circuit.storage&.clear(circuit.name)
-            circuit.half_open_attempts.value = 0
-            circuit.half_open_successes.value = 0
-          end
-
-          # Async-safe callbacks using modern API
-          after_transition to: :open do |circuit|
-            circuit.send(:on_circuit_open)
-          end
-
-          after_transition to: :closed do |circuit|
-            circuit.send(:on_circuit_close)
-          end
-
-          after_transition from: :open, to: :half_open do |circuit|
-            circuit.send(:on_circuit_half_open)
-          end
+          instance_eval(&StateMachineDefinition::COMMON)
         end
 
         # Additional async event methods are automatically generated:

data/lib/breaker_machines/circuit/coordinated_state_management.rb

@@ -10,11 +10,6 @@ module BreakerMachines
       included do
         # Override the state machine to add coordinated guards
         state_machine :status, initial: :closed do
-          event :trip do
-            transition closed: :open
-            transition half_open: :open
-          end
-
           event :attempt_recovery do
             transition open: :half_open,
                        if: lambda(&:recovery_allowed?)
@@ -26,35 +21,7 @@ module BreakerMachines
             transition closed: :closed
           end
 
-          event :force_open do
-            transition any => :open
-          end
-
-          event :force_close do
-            transition any => :closed
-          end
-
-          event :hard_reset do
-            transition any => :closed
-          end
-
-          before_transition on: :hard_reset do |circuit|
-            circuit.storage&.clear(circuit.name)
-            circuit.half_open_attempts.value = 0
-            circuit.half_open_successes.value = 0
-          end
-
-          after_transition to: :open do |circuit|
-            circuit.send(:on_circuit_open)
-          end
-
-          after_transition to: :closed do |circuit|
-            circuit.send(:on_circuit_close)
-          end
-
-          after_transition from: :open, to: :half_open do |circuit|
-            circuit.send(:on_circuit_half_open)
-          end
+          instance_eval(&StateMachineDefinition::COMMON)
         end
       end
 

data/lib/breaker_machines/circuit/state_machine_definition.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module BreakerMachines
+  class Circuit
+    # Shared state machine definition for circuit breakers.
+    #
+    # The trip/force_open/force_close/hard_reset events and the transition
+    # callbacks are identical across the sync, async, and coordinated state
+    # management modules. Only the +attempt_recovery+ and +reset+ events differ
+    # (coordinated circuits add guard conditions), so those stay in each module
+    # while everything common is spliced in via instance_eval(&COMMON).
+    module StateMachineDefinition
+      COMMON = proc do
+        event :trip do
+          transition closed: :open
+          transition half_open: :open
+        end
+
+        event :force_open do
+          transition any => :open
+        end
+
+        event :force_close do
+          transition any => :closed
+        end
+
+        event :hard_reset do
+          transition any => :closed
+        end
+
+        before_transition on: :hard_reset do |circuit|
+          circuit.storage&.clear(circuit.name)
+          circuit.half_open_attempts.value = 0
+          circuit.half_open_successes.value = 0
+        end
+
+        after_transition to: :open do |circuit|
+          circuit.send(:on_circuit_open)
+        end
+
+        after_transition to: :closed do |circuit|
+          circuit.send(:on_circuit_close)
+        end
+
+        after_transition from: :open, to: :half_open do |circuit|
+          circuit.send(:on_circuit_half_open)
+        end
+      end
+    end
+  end
+end

data/lib/breaker_machines/circuit/state_management.rb

@@ -9,11 +9,6 @@ module BreakerMachines
 
       included do
         state_machine :status, initial: :closed do
-          event :trip do
-            transition closed: :open
-            transition half_open: :open
-          end
-
           event :attempt_recovery do
             transition open: :half_open
           end
@@ -23,35 +18,7 @@ module BreakerMachines
             transition closed: :closed
           end
 
-          event :force_open do
-            transition any => :open
-          end
-
-          event :force_close do
-            transition any => :closed
-          end
-
-          event :hard_reset do
-            transition any => :closed
-          end
-
-          before_transition on: :hard_reset do |circuit|
-            circuit.storage&.clear(circuit.name)
-            circuit.half_open_attempts.value = 0
-            circuit.half_open_successes.value = 0
-          end
-
-          after_transition to: :open do |circuit|
-            circuit.send(:on_circuit_open)
-          end
-
-          after_transition to: :closed do |circuit|
-            circuit.send(:on_circuit_close)
-          end
-
-          after_transition from: :open, to: :half_open do |circuit|
-            circuit.send(:on_circuit_half_open)
-          end
+          instance_eval(&StateMachineDefinition::COMMON)
         end
       end
     end

data/lib/breaker_machines/storage/bucket_memory.rb

@@ -12,6 +12,8 @@ module BreakerMachines
     # environments as memory is not shared between processes. Use Cache backend
     # with an external cache store (Redis, Memcached) for distributed setups.
     class BucketMemory < Base
+      include MemorySupport
+
       BUCKET_SIZE = 1 # 1 second per bucket
 
       def initialize(**options)
@@ -25,40 +27,6 @@ module BreakerMachines
         @start_time = BreakerMachines.monotonic_time
       end
 
-      def get_status(circuit_name)
-        circuit_data = @circuits[circuit_name]
-        return nil unless circuit_data
-
-        BreakerMachines::Status.new(
-          status: circuit_data[:status],
-          opened_at: circuit_data[:opened_at]
-        )
-      end
-
-      def set_status(circuit_name, status, opened_at = nil)
-        @circuits[circuit_name] = {
-          status: status,
-          opened_at: opened_at,
-          updated_at: monotonic_time
-        }
-      end
-
-      def record_success(circuit_name, duration)
-        record_event(circuit_name, :success, duration)
-      end
-
-      def record_failure(circuit_name, duration)
-        record_event(circuit_name, :failure, duration)
-      end
-
-      def success_count(circuit_name, window_seconds)
-        count_events(circuit_name, :success, window_seconds)
-      end
-
-      def failure_count(circuit_name, window_seconds)
-        count_events(circuit_name, :failure, window_seconds)
-      end
-
       def clear(circuit_name)
         @circuits.delete(circuit_name)
         @circuit_buckets.delete(circuit_name)
@@ -71,32 +39,6 @@ module BreakerMachines
         @event_logs.clear
       end
 
-      def record_event_with_details(circuit_name, type, duration, error: nil, new_state: nil)
-        events = @event_logs.compute_if_absent(circuit_name) { Concurrent::Array.new }
-
-        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
-
-        # Keep only the most recent events
-        events.shift while events.size > @max_events
-      end
-
-      def event_log(circuit_name, limit)
-        events = @event_logs[circuit_name]
-        return [] unless events
-
-        events.last(limit).map(&:dup)
-      end
-
       private
 
       def record_event(circuit_name, type, _duration)
@@ -161,11 +103,6 @@ module BreakerMachines
         (monotonic_time / BUCKET_SIZE).to_i
       end
 
-      def monotonic_time
-        # Return time relative to storage creation (matches Rust implementation)
-        BreakerMachines.monotonic_time - @start_time
-      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

data/lib/breaker_machines/storage/memory.rb

@@ -11,6 +11,8 @@ module BreakerMachines
     # environments as memory is not shared between processes. Use Cache backend
     # with an external cache store (Redis, Memcached) for distributed setups.
     class Memory < Base
+      include MemorySupport
+
       def initialize(**options)
         super
         @circuits = Concurrent::Map.new
@@ -21,40 +23,6 @@ module BreakerMachines
         @start_time = BreakerMachines.monotonic_time
       end
 
-      def get_status(circuit_name)
-        circuit_data = @circuits[circuit_name]
-        return nil unless circuit_data
-
-        BreakerMachines::Status.new(
-          status: circuit_data[:status],
-          opened_at: circuit_data[:opened_at]
-        )
-      end
-
-      def set_status(circuit_name, status, opened_at = nil)
-        @circuits[circuit_name] = {
-          status: status,
-          opened_at: opened_at,
-          updated_at: monotonic_time
-        }
-      end
-
-      def record_success(circuit_name, duration)
-        record_event(circuit_name, :success, duration)
-      end
-
-      def record_failure(circuit_name, duration)
-        record_event(circuit_name, :failure, duration)
-      end
-
-      def success_count(circuit_name, window_seconds)
-        count_events(circuit_name, :success, window_seconds)
-      end
-
-      def failure_count(circuit_name, window_seconds)
-        count_events(circuit_name, :failure, window_seconds)
-      end
-
       def clear(circuit_name)
         @circuits.delete(circuit_name)
         @events.delete(circuit_name)
@@ -67,32 +35,6 @@ module BreakerMachines
         @event_logs.clear
       end
 
-      def record_event_with_details(circuit_name, type, duration, error: nil, new_state: nil)
-        events = @event_logs.compute_if_absent(circuit_name) { Concurrent::Array.new }
-
-        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
-
-        # Keep only the most recent events
-        events.shift while events.size > @max_events
-      end
-
-      def event_log(circuit_name, limit)
-        events = @event_logs[circuit_name]
-        return [] unless events
-
-        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
@@ -130,11 +72,6 @@ module BreakerMachines
         cutoff_time = monotonic_time - window_seconds
         events.count { |e| e[:type] == type && e[:timestamp] >= cutoff_time }
       end
-
-      def monotonic_time
-        # Return time relative to storage creation (matches Rust implementation)
-        BreakerMachines.monotonic_time - @start_time
-      end
     end
   end
 end

data/lib/breaker_machines/storage/memory_support.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module BreakerMachines
+  module Storage
+    # Methods shared by the in-memory storage backends (Memory and BucketMemory).
+    #
+    # Status storage, event-detail logging and the relative monotonic clock are
+    # identical between the two backends; only the event counting strategy
+    # (raw event arrays vs. fixed-size buckets) differs, so those methods stay
+    # in each backend.
+    module MemorySupport
+      def get_status(circuit_name)
+        circuit_data = @circuits[circuit_name]
+        return nil unless circuit_data
+
+        BreakerMachines::Status.new(
+          status: circuit_data[:status],
+          opened_at: circuit_data[:opened_at]
+        )
+      end
+
+      def set_status(circuit_name, status, opened_at = nil)
+        @circuits[circuit_name] = {
+          status: status,
+          opened_at: opened_at,
+          updated_at: monotonic_time
+        }
+      end
+
+      def record_success(circuit_name, duration)
+        record_event(circuit_name, :success, duration)
+      end
+
+      def record_failure(circuit_name, duration)
+        record_event(circuit_name, :failure, duration)
+      end
+
+      def success_count(circuit_name, window_seconds)
+        count_events(circuit_name, :success, window_seconds)
+      end
+
+      def failure_count(circuit_name, window_seconds)
+        count_events(circuit_name, :failure, window_seconds)
+      end
+
+      def record_event_with_details(circuit_name, type, duration, error: nil, new_state: nil)
+        events = @event_logs.compute_if_absent(circuit_name) { Concurrent::Array.new }
+
+        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
+
+        # Keep only the most recent events
+        events.shift while events.size > @max_events
+      end
+
+      def event_log(circuit_name, limit)
+        events = @event_logs[circuit_name]
+        return [] unless events
+
+        events.last(limit).map(&:dup)
+      end
+
+      private
+
+      def monotonic_time
+        # Return time relative to storage creation (matches Rust implementation)
+        BreakerMachines.monotonic_time - @start_time
+      end
+    end
+  end
+end

data/lib/breaker_machines/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: breaker_machines
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.2
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.100.4
+        version: 0.200.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.100.4
+        version: 0.200.0
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -164,6 +164,7 @@ files:
 - lib/breaker_machines/circuit/introspection.rb
 - lib/breaker_machines/circuit/native.rb
 - lib/breaker_machines/circuit/state_callbacks.rb
+- lib/breaker_machines/circuit/state_machine_definition.rb
 - lib/breaker_machines/circuit/state_management.rb
 - lib/breaker_machines/circuit_group.rb
 - lib/breaker_machines/console.rb
@@ -185,6 +186,7 @@ files:
 - lib/breaker_machines/storage/cache.rb
 - lib/breaker_machines/storage/fallback_chain.rb
 - lib/breaker_machines/storage/memory.rb
+- lib/breaker_machines/storage/memory_support.rb
 - lib/breaker_machines/storage/native.rb
 - lib/breaker_machines/storage/null.rb
 - lib/breaker_machines/types.rb