breaker_machines 0.11.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd34f2d2c0993335422fcb7c9a2495af660ec6c59dde5f57c7f9da0841cb51db
-  data.tar.gz: fc1ba508ecbaf43dbf451ef81bcacb9b586a0003ca5148d66d80f4d51a53f926
+  metadata.gz: 162c659f4b4f5c54672f4eaadfa57a51caae58fce8f03ffb3a4d1347144a42d7
+  data.tar.gz: 90baffaebfdb68b162fcdcc05056c1058af6ae875132c0fe429537b11b8ea3fc
 SHA512:
-  metadata.gz: 49eac0d2918c9cee306309f785009fe53ffbd4d4a26641132f2dfe8a069e0cb200a47a3d97a8748ae1bf52d4604969127d3c549db2e31cf6e25d0b95ce9eb65c
-  data.tar.gz: a08fa2490b8b2a3b1ac6bc44853540763875ce39ce439c860b682256f01ccfbdf5e5e63176f917d9c109a3593b573a32588dddb336c34d0a1023c00bbe4c15c5
+  metadata.gz: 00505d9351f6d05d4d6493941e20a8c358de0ca5ee21ca3b5868c89484602dc742558ee271bf814d98d2dceb4d52ce87fc2ee32cb1d9a8b204bdc534db09a1fb
+  data.tar.gz: 63ce970ef5041356488e9cc9a8342a01edd0f07ce3ac665a4bdb53733e09e69c9589dc23b540f2257043eed57f91528ff3dbd8fb8e88d25ab7277abded787ffc

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.11.0'
+  VERSION = '0.13.0'
 end

data/sig/README.md

@@ -71,4 +71,4 @@ end
 The type signatures define several interfaces:
 - `_StorageBackend` - For custom storage implementations
 - `_MetricsRecorder` - For custom metrics recording
-- `_CircuitLike` - For circuit-compatible objects
+- `_CircuitLike` - For circuit-compatible objects

data/sig/all.rbs

@@ -22,4 +22,4 @@
 
 # Import all type definitions
 use BreakerMachines::*
-use BreakerMachines::Storage::*
+use BreakerMachines::Storage::*

data/sig/breaker_machines/circuit.rbs

@@ -151,4 +151,4 @@ module BreakerMachines
     def invoke_fallback: (StandardError error) -> untyped
     def invoke_single_fallback: (Proc | untyped fallback, StandardError error) -> untyped
   end
-end
+end

data/sig/breaker_machines/console.rbs

@@ -29,4 +29,4 @@ module BreakerMachines
     def colorize_state: (Symbol state) -> String
     def colorize_event_type: (Symbol type) -> String
   end
-end
+end

data/sig/breaker_machines/dsl.rbs

@@ -47,4 +47,4 @@ module BreakerMachines
       def parallel_calls: (Integer count, ?timeout: Integer?) -> void
     end
   end
-end
+end

data/sig/breaker_machines/errors.rbs

@@ -21,4 +21,4 @@ module BreakerMachines
 
   class StorageError < Error
   end
-end
+end

data/sig/breaker_machines/interfaces.rbs

@@ -43,4 +43,4 @@ module BreakerMachines
     def reset: () -> bool
     def stats: () -> Hash[Symbol, untyped]
   end
-end
+end

data/sig/breaker_machines/registry.rbs

@@ -27,4 +27,4 @@ module BreakerMachines
 
     def cleanup_dead_references_unsafe: () -> void
   end
-end
+end

data/sig/breaker_machines/storage.rbs

@@ -62,4 +62,4 @@ module BreakerMachines
       def event_log: (String circuit_name, ?Integer limit) -> Array[untyped]
     end
   end
-end
+end

data/sig/breaker_machines/types.rbs

@@ -94,4 +94,4 @@ module BreakerMachines
     status: circuit_state,
     opened_at: Float?
   }
-end
+end

data/sig/manifest.yaml

@@ -2,4 +2,4 @@ dependencies:
   - name: activesupport
   - name: concurrent-ruby
   - name: state_machines
-  - name: zeitwerk
+  - name: zeitwerk