breaker_machines 0.21.2 → 0.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca6a74b2ade5414f83cd68ce2f160672d867ddd26b1ed8b5c8e033d20005e364
-  data.tar.gz: 88d044647e231cf66e7b463eb2fbf9fa1e7a9762827a2349716cee29a4e8369c
+  metadata.gz: deabe27c242daf0d590e59854866aa82de852bd5bf23a9dbc68ddb744c241b1d
+  data.tar.gz: 461633a405ff2e17ff26b604ea92c05a2323e777a0a439149915a3d50a7e2a5c
 SHA512:
-  metadata.gz: 6d009cbbe89e2ab5c38d2aaaaeb6148c1cb24199da282479cd436c31be68dd2fe09de70d6ac4208be3e96b7d11c92b77b33960656248a2337d1b4b66cbd4eff7
-  data.tar.gz: 3072f5bda0574496547d325de2e60b47f675961ef2755c755a4f3d486ec4c112628afad7e360f8fe22d8f87ff14a7d41ac899b29464a2f12d2b68f198ce941d6
+  metadata.gz: 8ecf93848f13975efb9740e41fd2d76468ab7da07d9ba6667ae1e1e408eaa6739030c7c178631b5039f29229da4da7a37a1ae94d0f6a69172d1b199bf268c897
+  data.tar.gz: 2133bf3bf089fcbaab9974ea9cf5ea00da860c4f1a87b28df1301e022371e34143526d4c9eabafddb16fca822b53827bf154af957be0edef837b7421ce6cd0a5

data/lib/breaker_machines/console.rb

@@ -221,7 +221,11 @@ module BreakerMachines
           puts '-' * 80
 
           events.each do |event|
-            timestamp = Time.at(event[:timestamp]).strftime('%Y-%m-%d %H:%M:%S')
+            timestamp = if event[:timestamp_epoch]
+                          Time.at(event[:timestamp_epoch]).strftime('%Y-%m-%d %H:%M:%S')
+                        else
+                          format('%.3fs', event[:timestamp])
+                        end
             type = colorize_event_type(event[:type])
             duration = event[:duration_ms] ? "#{event[:duration_ms]}ms" : '-'
             error = event[:error_class] || '-'

data/lib/breaker_machines/storage/cache.rb

@@ -15,6 +15,9 @@ module BreakerMachines
         @bucket_seconds = Integer(options[:bucket_seconds] || 1)
         raise ArgumentError, 'bucket_seconds must be positive' unless @bucket_seconds.positive?
 
+        @max_events = Integer(options[:max_events] || 100)
+        raise ArgumentError, 'max_events must be positive' unless @max_events.positive?
+
         @warned_windows = Concurrent::Set.new
       end
 
@@ -67,28 +70,23 @@ module BreakerMachines
         keys = [success_key(circuit_name), failure_key(circuit_name)].flat_map do |key|
           bucket_keys(key, bucket_count(@expires_in) + 1)
         end
-        delete_counters(keys)
+        delete_counters(keys + [event_sequence_key(circuit_name)] + event_slot_keys(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
+        return @cache.delete_matched(prefix_matcher) if @cache.respond_to?(:delete_matched)
+
+        warn_clear_all_unsupported
+      rescue NotImplementedError
+        warn_clear_all_unsupported
       end
 
       def record_event_with_details(circuit_name, type, duration, error: nil, new_state: nil)
-        events = @cache.fetch(events_key(circuit_name)) { [] }
-
+        now = monotonic_time
         event = {
           type: type,
-          timestamp: monotonic_time,
+          timestamp: now,
+          timestamp_epoch: BreakerMachines.monotonic_to_epoch(now),
           duration_ms: (duration * 1000).round(2)
         }
 
@@ -96,15 +94,24 @@ module BreakerMachines
         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)
+        return append_event(circuit_name, event) unless @cache.respond_to?(:increment)
 
-        @cache.write(events_key(circuit_name), events, expires_in: @expires_in)
+        sequence = @cache.increment(event_sequence_key(circuit_name), 1, expires_in: @expires_in)
+        return false unless sequence
+
+        @cache.write(event_slot_key(circuit_name, sequence % @max_events),
+                     event.merge(sequence: sequence), expires_in: @expires_in)
       end
 
       def event_log(circuit_name, limit)
-        events = @cache.read(events_key(circuit_name)) || []
-        events.last(limit)
+        events = if @cache.respond_to?(:increment)
+                   read_values(event_slot_keys(circuit_name)).sort_by do |event|
+                     [event[:timestamp_epoch], event[:sequence]]
+                   end
+                 else
+                   @cache.read(events_key(circuit_name)) || []
+                 end
+        events.last(limit).map { |event| local_event(event) }
       end
 
       def with_timeout(_timeout_ms)
@@ -165,9 +172,39 @@ module BreakerMachines
 
       # read_multi is a single round trip; stores without it read each bucket.
       def read_counters(keys)
-        return @cache.read_multi(*keys, raw: true).values if @cache.respond_to?(:read_multi)
+        read_values(keys, raw: true)
+      end
+
+      def read_values(keys, **options)
+        return @cache.read_multi(*keys, **options).values if @cache.respond_to?(:read_multi)
+
+        keys.filter_map { |key| @cache.read(key, options) }
+      end
 
-        keys.filter_map { |key| @cache.read(key) }
+      def append_event(circuit_name, event)
+        events = @cache.fetch(events_key(circuit_name)) { [] }
+        events << event
+        events.shift while events.size > @max_events
+        @cache.write(events_key(circuit_name), events, expires_in: @expires_in)
+      end
+
+      def local_event(event)
+        epoch = event[:timestamp_epoch]
+        local = event.except(:sequence)
+        epoch ? local.merge(timestamp: BreakerMachines.epoch_to_monotonic(epoch)) : local
+      end
+
+      def prefix_matcher
+        return "#{@prefix.gsub(/[?*\[\]\\]/) { |char| "\\#{char}" }}:*" if @cache.respond_to?(:redis)
+
+        /^#{Regexp.escape(@prefix)}:/
+      end
+
+      def warn_clear_all_unsupported
+        BreakerMachines.logger&.warn(
+          "[BreakerMachines] #{@cache.class} doesn't support delete_matched. " \
+          'Individual circuit data must be cleared manually.'
+        )
       end
 
       def delete_counters(keys)
@@ -210,6 +247,18 @@ module BreakerMachines
         "#{@prefix}:#{circuit_name}:events"
       end
 
+      def event_sequence_key(circuit_name)
+        "#{@prefix}:#{circuit_name}:event_sequence"
+      end
+
+      def event_slot_key(circuit_name, slot)
+        "#{@prefix}:#{circuit_name}:event:#{slot}"
+      end
+
+      def event_slot_keys(circuit_name)
+        Array.new(@max_events) { |slot| event_slot_key(circuit_name, slot) }
+      end
+
       def monotonic_time
         BreakerMachines.monotonic_time
       end

data/lib/breaker_machines/storage/memory_support.rb

@@ -46,9 +46,11 @@ module BreakerMachines
       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 }
 
+        now = monotonic_time
         event = {
           type: type,
-          timestamp: monotonic_time,
+          timestamp: now,
+          timestamp_epoch: BreakerMachines.monotonic_to_epoch(@start_time + now),
           duration_ms: (duration * 1000).round(2)
         }
 

data/lib/breaker_machines/storage/native.rb

@@ -24,6 +24,7 @@ module BreakerMachines
         super
         # Native extension is guaranteed to be available when this class is loaded
         @backend = BreakerMachinesNative::Storage.new
+        @epoch_origin = BreakerMachines.monotonic_to_epoch(BreakerMachines.monotonic_time)
       end
 
       # Check if using native backend
@@ -81,7 +82,9 @@ module BreakerMachines
       end
 
       def event_log(circuit_name, limit)
-        @backend.event_log(circuit_name.to_s, limit)
+        @backend.event_log(circuit_name.to_s, limit).map do |event|
+          event.merge(timestamp_epoch: @epoch_origin + event[:timestamp])
+        end
       end
 
       def with_timeout(_timeout_ms)

data/lib/breaker_machines/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: breaker_machines
 version: !ruby/object:Gem::Version
-  version: 0.21.2
+  version: 0.22.1
 platform: ruby
 authors:
 - Abdelkader Boudih