throttle_machines 0.3.4-x86_64-linux → 0.4.1-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c66ed002f19fead80fd931c2fef895b7ac3778437d72d9ff01642b1876ae7e4
-  data.tar.gz: 364c295404364d6206048e7a7f350907400450cfd47e73cbcd832294f00aa592
+  metadata.gz: f9845ae006c5ed94c11b0caf7f711429e87cc940d87b5a4e0cb9f44b2c87ebde
+  data.tar.gz: 1db546c88542f9292505622fc38a5834adf33516ecd93a4ae1277aebc9e4e340
 SHA512:
-  metadata.gz: e73aacb0fadd1522578b92a81dc86e1a5ec3af3b15389d01558bc3030c90e84ced71f0a82404bd5fb07ac93e6b8e999912659263b70f367c9d83de22c2c3ef7f
-  data.tar.gz: 368c382b90c4621b237dac12fed6e8ba86198023e6b351ab3db591b76b33672942e0b3faf68124bc725ebf491ae81a6a3ece8731c41c601ffef80fb4ba9c17a8
+  metadata.gz: b792e326672faffe29cda49e1cf7f7e3ebb285136a3708f1faef0377550762cdc4c502a175e1d9db97d6d8ca88502f35a9b6c00eb9b4409b07ffc08b0f0f9252
+  data.tar.gz: 12153978d4b5293e91e50dfc3565cb83094e7d281b8e7fcd74eff8873b7f3eddfa11dd5362f911d29fdc3bcb2c085b6cf230e57c138bd0b89756cb4840c0ac8f

data/lib/throttle_machines/async_support.rb

@@ -22,26 +22,25 @@ module ThrottleMachines
     end
 
     def throttle_async(max_wait: nil, &block)
-      deadline = max_wait.nil? ? nil : ThrottleMachines.monotonic_time + max_wait.to_f
-
-      loop do
-        begin
-          throttle!
-        rescue ThrottledError => e
-          wait_time = [e.retry_after.to_f, 0.0].max
-
-          if deadline
-            remaining_wait = deadline - ThrottleMachines.monotonic_time
-            raise if remaining_wait <= 0 || wait_time > remaining_wait
+      caller_budget = DeadlineMachines.current
+
+      DeadlineMachines.with_deadline(max_wait) do |budget|
+        loop do
+          begin
+            throttle!
+          rescue ThrottledError => e
+            caller_budget&.check!
+            wait_time = [e.retry_after.to_f, 0.0].max
+            raise if budget.clamp_sleep(wait_time) < wait_time
+
+            sleep_for(wait_time)
+            next
           end
 
-          sleep_for(wait_time)
-          next
-        end
+          return block.call if block
 
-        return block.call if block
-
-        return true
+          return true
+        end
       end
     end
 

data/lib/throttle_machines/control.rb

@@ -27,7 +27,7 @@ module ThrottleMachines
     def retry_on_failure(times:, backoff: :exponential, base_delay: 1, max_delay: 60)
       @rules[:retry] = {
         max_attempts: times,
-        jitter: backoff,
+        backoff: backoff,
         base_delay: base_delay,
         max_delay: max_delay
       }
@@ -87,7 +87,8 @@ module ThrottleMachines
         max_attempts: @rules[:retry][:max_attempts],
         base_delay: @rules[:retry][:base_delay],
         max_delay: @rules[:retry][:max_delay],
-        jitter_factor: @rules[:retry][:jitter] == :exponential ? 1.0 : 0.0
+        backoff_strategy: @rules[:retry][:backoff],
+        jitter_factor: @rules[:retry][:backoff] == :exponential ? 1.0 : 0.0
       }
       @retrier = ChronoMachines::Executor.new(policy_options)
     end

data/lib/throttle_machines/hedged_request.rb

@@ -56,9 +56,9 @@ module ThrottleMachines
       @max_attempts.times do |attempt|
         # Schedule with delay
         future = if attempt.zero?
-                   Concurrent::Promises.future { yield(attempt) }
+                   Concurrent::Promises.future_on(@executor) { yield(attempt) }
                  else
-                   Concurrent::Promises.schedule(@delay * attempt) { yield(attempt) }
+                   Concurrent::Promises.schedule_on(@executor, @delay * attempt) { yield(attempt) }
                  end
 
         # Race to resolve first_result
@@ -88,9 +88,6 @@ module ThrottleMachines
       else
         first_result.value!
       end
-    ensure
-      # Cancel pending futures
-      futures.each { |f| f.cancel if f.pending? }
     end
 
     # Run async version

data/lib/throttle_machines/limiter.rb

@@ -11,6 +11,7 @@ module ThrottleMachines
       @algorithm = algorithm
       @storage = storage || ThrottleMachines.storage
       validate_algorithm!
+      validate_rate!
     end
 
     def allow?
@@ -94,8 +95,10 @@ module ThrottleMachines
       case @algorithm
       when :fixed_window
         @storage.reset_counter(@key, @period)
-      else
-        @storage.clear("#{@key}*")
+      when :gcra
+        @storage.reset_gcra(@key)
+      when :token_bucket
+        @storage.reset_token_bucket(@key)
       end
     end
 
@@ -167,6 +170,11 @@ module ThrottleMachines
 
     private
 
+    def validate_rate!
+      raise ArgumentError, "limit must be positive, got #{@limit.inspect}" unless @limit.is_a?(Numeric) && @limit.positive?
+      raise ArgumentError, "period must be positive, got #{@period.inspect}" unless @period.is_a?(Numeric) && @period.positive?
+    end
+
     def validate_algorithm!
       unless Storage::Base::ALGORITHM_OPERATIONS.key?(@algorithm)
         raise ArgumentError, "Unknown algorithm: #{@algorithm.inspect}"

data/lib/throttle_machines/storage/base.rb

@@ -5,12 +5,18 @@ module ThrottleMachines
     class Base
       ALGORITHM_OPERATIONS = {
         fixed_window: %i[increment_counter get_counter get_counter_ttl reset_counter],
-        gcra: %i[check_gcra_limit peek_gcra_limit],
-        token_bucket: %i[check_token_bucket peek_token_bucket]
+        gcra: %i[check_gcra_limit peek_gcra_limit reset_gcra],
+        token_bucket: %i[check_token_bucket peek_token_bucket reset_token_bucket]
       }.freeze
 
       HEALTH_KEY = 'throttle_machines:health'
 
+      # What a backend puts between a limiter's key and the state it appends.
+      KEY_SEPARATOR = ':'
+
+      GLOB_WILDCARD = '*'
+      GLOB_SPECIALS = /[*?\[\]\\]/
+
       def initialize(options = {})
         @options = options
       end
@@ -48,6 +54,10 @@ module ThrottleMachines
         raise NotImplementedError, "#{self.class} does not implement #peek_gcra_limit"
       end
 
+      def reset_gcra(key)
+        raise NotImplementedError, "#{self.class} does not implement #reset_gcra"
+      end
+
       # Token bucket operations (atomic)
       def check_token_bucket(key, capacity, refill_rate, ttl)
         raise NotImplementedError, "#{self.class} does not implement #check_token_bucket"
@@ -57,11 +67,20 @@ module ThrottleMachines
         raise NotImplementedError, "#{self.class} does not implement #peek_token_bucket"
       end
 
+      def reset_token_bucket(key)
+        raise NotImplementedError, "#{self.class} does not implement #reset_token_bucket"
+      end
+
       # Utility operations
       def clear(pattern = nil)
         raise NotImplementedError, "#{self.class} does not implement #clear"
       end
 
+      # Deletes every entry this key owns, whatever algorithm wrote it.
+      def reset_key(key)
+        raise NotImplementedError, "#{self.class} does not implement #reset_key"
+      end
+
       def healthy?
         get_counter(HEALTH_KEY, 1)
         true
@@ -70,9 +89,8 @@ module ThrottleMachines
       end
 
       def with_timeout(timeout, &block)
-        Timeout.timeout(timeout, &block)
-      rescue Timeout::Error
-        nil
+        DeadlineMachines.check!
+        Timeout.timeout(DeadlineMachines.clamp_sleep(timeout), &block)
       end
 
       # Rounding slack for time comparisons, in units of the clock's precision.
@@ -81,6 +99,18 @@ module ThrottleMachines
 
       protected
 
+      def owned_by?(stored_key, key)
+        stored_key == key || stored_key.start_with?("#{key}#{KEY_SEPARATOR}")
+      end
+
+      def escape_glob(literal)
+        literal.gsub(GLOB_SPECIALS) { |char| "\\#{char}" }
+      end
+
+      def glob_to_regexp(glob)
+        Regexp.new("\\A#{Regexp.escape(glob).gsub(Regexp.escape(GLOB_WILDCARD), '.*')}\\z")
+      end
+
       # Times are running sums and differences of float seconds, so an
       # on-schedule arrival can miss an exact boundary by a few ulps. The slack
       # scales with the clock's magnitude.

data/lib/throttle_machines/storage/cache.rb

@@ -3,7 +3,8 @@
 module ThrottleMachines
   module Storage
     class Cache < Base
-      GLOB_SPECIALS = /[?\[\]\\]/
+      # The wildcard a caller's pattern keeps; everything else is a literal.
+      PATTERN_SPECIALS = /[?\[\]\\]/
 
       def initialize(options = {})
         super
@@ -33,10 +34,13 @@ module ThrottleMachines
       end
 
       def clear(pattern = nil)
-        @cache.delete_matched(matcher_for("#{@prefix}:#{pattern || '*'}"))
-      rescue NotImplementedError
-        raise UnsupportedOperationError,
-              "#{@cache.class} cannot delete by pattern; reset limiters individually with Limiter#reset!"
+        delete_matched(matcher_for("#{@prefix}#{KEY_SEPARATOR}#{pattern || GLOB_WILDCARD}"))
+      end
+
+      # The window and the bucket index a counter was written under are unknown
+      # here, so the counters go by a prefix of the key's own namespace.
+      def reset_key(key)
+        delete_matched(prefix_matcher("#{@prefix}#{KEY_SEPARATOR}#{key}#{KEY_SEPARATOR}"))
       end
 
       def healthy?
@@ -59,10 +63,24 @@ module ThrottleMachines
         window
       end
 
+      def delete_matched(matcher)
+        @cache.delete_matched(matcher)
+      rescue NotImplementedError
+        raise UnsupportedOperationError,
+              "#{@cache.class} cannot delete by pattern; reset limiters individually with Limiter#reset!"
+      end
+
       def matcher_for(glob)
-        return glob.gsub(GLOB_SPECIALS) { |char| "\\#{char}" } if @cache.respond_to?(:redis)
+        return glob.gsub(PATTERN_SPECIALS) { |char| "\\#{char}" } if @cache.respond_to?(:redis)
+
+        Regexp.new("^#{Regexp.escape(glob).gsub(Regexp.escape(GLOB_WILDCARD), '.*')}")
+      end
+
+      def prefix_matcher(literal)
+        return "#{escape_glob(literal)}#{GLOB_WILDCARD}" if @cache.respond_to?(:redis)
 
-        Regexp.new("^#{Regexp.escape(glob).gsub('\*', '.*')}")
+        # ActiveSupport only prepends a store's namespace to a `^` source.
+        Regexp.new("^#{Regexp.escape(literal)}")
       end
 
       def wall_time

data/lib/throttle_machines/storage/memory.rb

@@ -7,37 +7,36 @@ module ThrottleMachines
     class Memory < Base
       DEFAULT_MAX_KEYS = 65_536
       CAPACITY_RETRY_AFTER = 1.0
+      DEFAULT_CLEANUP_INTERVAL = 60
+      DEFAULT_LOCK_POOL_SIZE = 32
+      SHUTDOWN_GRACE = 1.0
 
       def initialize(options = {})
         super
-        @max_keys = options.fetch(:max_keys, DEFAULT_MAX_KEYS)
-        unless @max_keys.is_a?(Integer) && @max_keys >= 0
-          raise ArgumentError, 'max_keys must be a non-negative integer'
-        end
+        max_keys = options.fetch(:max_keys, DEFAULT_MAX_KEYS)
+        raise ArgumentError, 'max_keys must be a non-negative integer' unless max_keys.is_a?(Integer) && max_keys >= 0
+
+        @state = State.new(
+          max_keys: max_keys,
+          lock_pool_size: options[:lock_pool_size] || DEFAULT_LOCK_POOL_SIZE,
+          cleanup_interval: options[:cleanup_interval] || DEFAULT_CLEANUP_INTERVAL
+        )
+        @counters = @state.counters
+        @gcra_states = @state.gcra_states
+        @token_buckets = @state.token_buckets
 
-        @stored_keys = 0
-        @capacity_lock = Mutex.new
         @capacity_cleanup_lock = Mutex.new
         @next_capacity_cleanup_at = -Float::INFINITY
-        @counters = Concurrent::Hash.new
-        @gcra_states = Concurrent::Hash.new
-        @token_buckets = Concurrent::Hash.new
-
-        # Use a striped lock pattern - pool of locks for fine-grained concurrency
-        @lock_pool_size = options[:lock_pool_size] || 32
-        @locks = Array.new(@lock_pool_size) { Concurrent::ReadWriteLock.new }
+        @cleanup_thread = nil
 
-        # Background cleanup thread
-        @cleanup_interval = options[:cleanup_interval] || 60
-        @shutdown = false
-        @cleanup_thread = start_cleanup_thread if options[:auto_cleanup] != false
+        return if options[:auto_cleanup] == false
 
-        # Ensure cleanup on garbage collection
+        @cleanup_thread = @state.start_cleanup_thread
         ObjectSpace.define_finalizer(self, self.class.finalizer(@cleanup_thread))
       end
 
       def self.finalizer(cleanup_thread)
-        proc { cleanup_thread&.kill }
+        proc { cleanup_thread.kill }
       end
 
       # Rate limiting operations
@@ -113,7 +112,7 @@ module ThrottleMachines
 
           {
             allowed: allow,
-            retry_after: allow ? 0 : (tat - now - delay_tolerance),
+            retry_after: allow ? 0.0 : (tat - now - delay_tolerance),
             tat: tat
           }
         end
@@ -132,12 +131,16 @@ module ThrottleMachines
 
           {
             allowed: allow,
-            retry_after: allow ? 0 : (tat - now - delay_tolerance),
+            retry_after: allow ? 0.0 : (tat - now - delay_tolerance),
             tat: tat
           }
         end
       end
 
+      def reset_gcra(key)
+        with_write_lock(key) { delete_entry(@gcra_states, key) }
+      end
+
       # Token bucket operations (atomic simulation)
       def check_token_bucket(key, capacity, refill_rate, ttl)
         reclaim_capacity
@@ -160,7 +163,7 @@ module ThrottleMachines
 
             {
               allowed: true,
-              retry_after: 0,
+              retry_after: 0.0,
               tokens_remaining: bucket[:tokens].floor
             }
           else
@@ -191,7 +194,7 @@ module ThrottleMachines
           if token_available?(current_tokens, now, refill_rate)
             {
               allowed: true,
-              retry_after: 0,
+              retry_after: 0.0,
               tokens_remaining: [current_tokens - 1, 0].max.floor
             }
           else
@@ -206,65 +209,58 @@ module ThrottleMachines
         end
       end
 
+      def reset_token_bucket(key)
+        with_write_lock(key) { delete_entry(@token_buckets, key) }
+      end
+
       # No circuit breaker operations here: breaker state is owned by BreakerMachines
 
       # Utility operations
       def clear(pattern = nil)
         if pattern
-          regex = Regexp.new(pattern.gsub('*', '.*'))
-
-          # Clear matching keys from all stores
-          [@counters, @gcra_states, @token_buckets].each do |store|
-            store.keys.each do |k|
-              with_write_lock(k) { delete_entry(store, k) } if k&.match?(regex)
-            end
-          end
+          regex = glob_to_regexp(pattern)
+          delete_where { |stored_key| stored_key.match?(regex) }
         else
-          @capacity_lock.synchronize do
-            @counters.clear
-            @gcra_states.clear
-            @token_buckets.clear
-            @stored_keys = 0
-          end
+          @state.clear_all
         end
       end
 
+      def reset_key(key)
+        delete_where { |stored_key| owned_by?(stored_key, key) }
+      end
+
       def healthy?
         true
       end
 
       def shutdown
-        @shutdown = true
-        @cleanup_thread&.join(1) # Wait up to 1 second for graceful shutdown
-        @cleanup_thread&.kill if @cleanup_thread&.alive?
+        @state.shutdown!
+        @cleanup_thread&.join(SHUTDOWN_GRACE)
+        @cleanup_thread&.kill
         @cleanup_thread = nil
+        ObjectSpace.undefine_finalizer(self)
       end
 
       private
 
-      # Called with the key's write lock held. The short admission lock makes
-      # the cap atomic across stripes and all three stores.
-      def store_entry(store, key, value)
-        @capacity_lock.synchronize do
-          new_key = !store.key?(key)
-          return false if new_key && @stored_keys >= @max_keys
-
-          store[key] = value
-          @stored_keys += 1 if new_key
-          true
+      def delete_where
+        @state.stores.each do |store|
+          store.keys.each do |stored_key|
+            with_write_lock(stored_key) { delete_entry(store, stored_key) } if yield(stored_key)
+          end
         end
       end
 
+      def store_entry(store, key, value)
+        @state.store_entry(store, key, value)
+      end
+
       def delete_entry(store, key)
-        @capacity_lock.synchronize do
-          value = store.delete(key)
-          @stored_keys -= 1 if value
-          value
-        end
+        @state.delete_entry(store, key)
       end
 
       def capacity_available?(store, key)
-        @capacity_lock.synchronize { store.key?(key) || @stored_keys < @max_keys }
+        @state.capacity_available?(store, key)
       end
 
       def capacity_gcra_refusal(now, delay_tolerance)
@@ -279,7 +275,7 @@ module ThrottleMachines
       # cleanup at most once per second, even with auto_cleanup disabled.
       # Rejected identity sprays must not trigger a full scan on every call.
       def reclaim_capacity
-        return unless @capacity_lock.synchronize { @stored_keys >= @max_keys }
+        return unless @state.saturated?
         return unless @capacity_cleanup_lock.try_lock
 
         begin
@@ -294,49 +290,133 @@ module ThrottleMachines
       end
 
       def with_read_lock(key, &block)
-        lock_for(key).with_read_lock(&block)
+        @state.with_read_lock(key, &block)
       end
 
       def with_write_lock(key, &block)
-        lock_for(key).with_write_lock(&block)
+        @state.with_write_lock(key, &block)
       end
 
-      def lock_for(key)
-        # Hash key to determine which lock to use
-        index = key.hash.abs % @lock_pool_size
-        @locks[index]
+      def clean_expired_entries
+        @state.clean_expired_entries
       end
 
-      def start_cleanup_thread
-        Thread.new do
-          loop do
-            break if @shutdown
+      # Holds every map, lock and counter the cleanup worker sweeps.
+      class State
+        attr_reader :counters, :gcra_states, :token_buckets
+
+        def initialize(max_keys:, lock_pool_size:, cleanup_interval:)
+          @max_keys = max_keys
+          @cleanup_interval = cleanup_interval
+          @stored_keys = 0
+          @capacity_lock = Mutex.new
+          @counters = Concurrent::Hash.new
+          @gcra_states = Concurrent::Hash.new
+          @token_buckets = Concurrent::Hash.new
+
+          # Use a striped lock pattern - pool of locks for fine-grained concurrency
+          @lock_pool_size = lock_pool_size
+          @locks = Array.new(lock_pool_size) { Concurrent::ReadWriteLock.new }
+          @shutdown = false
+        end
+
+        def start_cleanup_thread
+          Thread.new do
+            loop do
+              break if @shutdown
 
-            sleep @cleanup_interval
-            break if @shutdown
+              sleep @cleanup_interval
+              break if @shutdown
 
-            clean_expired_entries
+              clean_expired_entries
+            end
           end
         end
-      end
 
-      def clean_expired_entries
-        now = current_time
-
-        [@counters, @gcra_states, @token_buckets].each do |store|
-          store.keys.each do |key|
-            with_write_lock(key) do
-              # Re-read under the lock: a writer may have refreshed the TTL.
-              data = store[key]
-              delete_entry(store, key) if data && data[:expires_at] && data[:expires_at] <= now
+        def shutdown!
+          @shutdown = true
+        end
+
+        def stores
+          [@counters, @gcra_states, @token_buckets]
+        end
+
+        def stored_keys
+          @capacity_lock.synchronize { @stored_keys }
+        end
+
+        def saturated?
+          @capacity_lock.synchronize { @stored_keys >= @max_keys }
+        end
+
+        def with_read_lock(key, &block)
+          lock_for(key).with_read_lock(&block)
+        end
+
+        def with_write_lock(key, &block)
+          lock_for(key).with_write_lock(&block)
+        end
+
+        # Called with the key's write lock held. The short admission lock makes
+        # the cap atomic across stripes and all three stores.
+        def store_entry(store, key, value)
+          @capacity_lock.synchronize do
+            new_key = !store.key?(key)
+            return false if new_key && @stored_keys >= @max_keys
+
+            store[key] = value
+            @stored_keys += 1 if new_key
+            true
+          end
+        end
+
+        def delete_entry(store, key)
+          @capacity_lock.synchronize do
+            value = store.delete(key)
+            @stored_keys -= 1 if value
+            value
+          end
+        end
+
+        def capacity_available?(store, key)
+          @capacity_lock.synchronize { store.key?(key) || @stored_keys < @max_keys }
+        end
+
+        def clear_all
+          @capacity_lock.synchronize do
+            @counters.clear
+            @gcra_states.clear
+            @token_buckets.clear
+            @stored_keys = 0
+          end
+        end
+
+        def clean_expired_entries
+          now = ThrottleMachines.monotonic_time
+
+          stores.each do |store|
+            store.keys.each do |key|
+              with_write_lock(key) do
+                # Re-read under the lock: a writer may have refreshed the TTL.
+                data = store[key]
+                delete_entry(store, key) if data && data[:expires_at] && data[:expires_at] <= now
+              end
             end
           end
+
+          # No breaker state cleanup: breaker state is managed by BreakerMachines
+        rescue StandardError => e
+          # Log error but don't crash cleanup thread
+          warn "ThrottleMachines: Cleanup error: #{e.message}"
         end
 
-        # No breaker state cleanup: breaker state is managed by BreakerMachines
-      rescue StandardError => e
-        # Log error but don't crash cleanup thread
-        warn "ThrottleMachines: Cleanup error: #{e.message}"
+        private
+
+        def lock_for(key)
+          # Hash key to determine which lock to use
+          index = key.hash.abs % @lock_pool_size
+          @locks[index]
+        end
       end
     end
   end

data/lib/throttle_machines/storage/null.rb

@@ -37,6 +37,10 @@ module ThrottleMachines
         }
       end
 
+      def reset_gcra(_key)
+        true
+      end
+
       # Token bucket operations
       def check_token_bucket(_key, capacity, _refill_rate, _ttl)
         {
@@ -54,11 +58,19 @@ module ThrottleMachines
         }
       end
 
+      def reset_token_bucket(_key)
+        true
+      end
+
       # Utility operations
       def clear(_pattern = nil)
         true
       end
 
+      def reset_key(_key)
+        true
+      end
+
       def healthy?
         true
       end

data/lib/throttle_machines/storage/redis.rb

@@ -22,6 +22,9 @@ module ThrottleMachines
       PEEK_GCRA_SHA = Digest::SHA1.hexdigest(PEEK_GCRA_SCRIPT)
       PEEK_TOKEN_BUCKET_SHA = Digest::SHA1.hexdigest(PEEK_TOKEN_BUCKET_SCRIPT)
 
+      # Keys a single SCAN round trip asks for.
+      SCAN_BATCH = 100
+
       def initialize(options = {})
         super
         @redis = options[:redis] || options[:client] || options[:pool]
@@ -74,6 +77,10 @@ module ThrottleMachines
         }
       end
 
+      def reset_gcra(key)
+        delete_state(key)
+      end
+
       # Token bucket operations (atomic via Lua)
       def check_token_bucket(key, capacity, refill_rate, ttl)
         result = run_script(TOKEN_BUCKET_SCRIPT, TOKEN_BUCKET_SHA,
@@ -83,6 +90,10 @@ module ThrottleMachines
         token_bucket_result(result, refill_rate)
       end
 
+      def reset_token_bucket(key)
+        delete_state(key)
+      end
+
       # Peek methods for non-consuming checks
       def peek_gcra_limit(key, emission_interval, delay_tolerance)
         now = current_time
@@ -112,17 +123,14 @@ module ThrottleMachines
 
       # Utility operations
       def clear(pattern = nil)
-        # Use SCAN instead of KEYS to avoid blocking in production
-        cursor = '0'
-        scan_pattern = pattern ? prefixed(pattern) : "#{@prefix}*"
+        delete_matching(pattern ? prefixed(pattern) : "#{@prefix}#{GLOB_WILDCARD}")
+      end
 
-        with_redis do |redis|
-          loop do
-            cursor, keys = redis.scan(cursor, match: scan_pattern, count: 100)
-            redis.del(*keys) unless keys.empty?
-            break if cursor == '0'
-          end
-        end
+      # The window a counter was written under is unknown here, so the counters
+      # go by a glob over the key's own namespace; the key itself is a literal.
+      def reset_key(key)
+        delete_state(key)
+        delete_matching("#{escape_glob(prefixed(key))}#{KEY_SEPARATOR}#{GLOB_WILDCARD}")
       end
 
       def healthy?
@@ -133,6 +141,23 @@ module ThrottleMachines
 
       private
 
+      def delete_state(key)
+        with_redis { |r| r.del(prefixed(key)) }
+      end
+
+      # SCAN instead of KEYS, to avoid blocking in production.
+      def delete_matching(scan_pattern)
+        cursor = '0'
+
+        with_redis do |redis|
+          loop do
+            cursor, keys = redis.scan(cursor, match: scan_pattern, count: SCAN_BATCH)
+            redis.del(*keys) unless keys.empty?
+            break if cursor == '0'
+          end
+        end
+      end
+
       # `result` is [allowed, tokens]: the balance after an admission, or the
       # fractional balance a refusal waits on. Matches Storage::Memory.
       def token_bucket_result(result, refill_rate)

data/lib/throttle_machines/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ThrottleMachines
-  VERSION = '0.3.4'
+  VERSION = '0.4.1'
 end

data/lib/throttle_machines.rb

@@ -7,6 +7,7 @@ require 'active_support/core_ext/class/attribute'
 
 # Ecosystem dependencies
 require 'chrono_machines'
+require 'deadline_machines'
 require 'breaker_machines'
 
 # Set up Zeitwerk loader
@@ -75,7 +76,7 @@ module ThrottleMachines
 
     def reset!(key = nil)
       if key
-        storage.clear("#{key}*")
+        storage.reset_key(key)
       else
         storage.clear
         # Reset storage instance to force recreation with defaults
@@ -98,19 +99,16 @@ module ThrottleMachines
     end
 
     def break_circuit(key, failures:, timeout:, &block)
-      # Delegate to BreakerMachines; use reset_timeout for open duration
-      breaker = BreakerMachines::Circuit.new(
-        key,
-        failure_threshold: failures,
-        reset_timeout: timeout
-      )
-      breaker.call(&block)
+      BreakerMachines::Registry.instance.get_or_create_dynamic_circuit(
+        key, self, { failure_threshold: failures, reset_timeout: timeout }
+      ).call(&block)
     end
 
     def retry_with(max_attempts: 3, backoff: :exponential, &block)
       # Delegate to chrono_machines
       policy_options = {
         max_attempts: max_attempts,
+        backoff_strategy: backoff,
         jitter_factor: backoff == :exponential ? 1.0 : 0.0
       }
       ChronoMachines.retry(policy_options, &block)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: throttle_machines
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.1
 platform: x86_64-linux
 authors:
 - Abdelkader Boudih
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-10-30 00:00:00.000000000 Z
+date: 2026-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -72,28 +72,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.22.1
+        version: 0.24.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.22.1
+        version: 0.24.0
 - !ruby/object:Gem::Dependency
   name: chrono_machines
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: 0.12.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.1
+- !ruby/object:Gem::Dependency
+  name: deadline_machines
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement