throttle_machines 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21546f9777cfd269ba2461dd3a3200173591defc6f20effb84fa8b7fb254353c
-  data.tar.gz: 4f82a87423e163ba277c5707b65dc122b1f0ba047ed97c29b5a877c14af92d94
+  metadata.gz: ff1906a9e597bee94979f637bf351aa53160ec2b349005ed731069bdb85cd032
+  data.tar.gz: 2293e5d59855593686cc2a8df0df560c5286452bc63bbcea4e13fca04d824c92
 SHA512:
-  metadata.gz: 61d639a39194c9d504871e2159a30ab89671d3f42f333d1f283ecc7a7fb1c238d948a5dfa3c336a6c05fec5e3065613d00610027fbdcf6af0d3df5277dc02a2a
-  data.tar.gz: b844e1d3ce3949c273e996972770f7d5f1aa1d3a5729da02d54651915bd826b327dd2826e96d4c09ac6ac921e720b437494ed3eac4d2c7b8db776e6f50244d3a
+  metadata.gz: 7c1fa93375186f6036c1efcba1292207ba0c831ee0d5e5bb73b7c985e2d45b3c52362d79d590ad1904a25568040e00e5929373381fb48da57155a646e8588e24
+  data.tar.gz: ae5ffa6881f0e7913227de2991ae8ffd17af31525040e43741491691cddde6ee8e4d27a9a2ad5dd5d2537335237e008f3397e9c4d3f45fab123cdac850ee7c73

data/lib/throttle_machines/controller_helpers.rb

@@ -5,7 +5,7 @@ module ThrottleMachines
     extend ActiveSupport::Concern
 
     included do
-      if respond_to?(:helper_method)
+      if respond_to?(:helper_method) # No available in API Mode
         helper_method :rate_limited?
         helper_method :rate_limit_remaining
       end
@@ -21,10 +21,10 @@ module ThrottleMachines
       set_rate_limit_headers(limiter)
     end
 
-    def with_throttle(key = nil, limit:, period:, &)
+    def with_throttle(key = nil, limit:, period:, &block)
       key ||= default_throttle_key
 
-      ThrottleMachines.limit(key, limit: limit, period: period, &)
+      ThrottleMachines.limit(key, limit: limit, period: period, &block)
     rescue ThrottledError => e
       render_rate_limited(e.limiter)
     end

data/lib/throttle_machines/engine.rb

@@ -13,13 +13,6 @@ module ThrottleMachines
       end
     end
 
-    initializer 'throttle_machines.configure_defaults' do |_app|
-      ThrottleMachines.configure do |config|
-        # Use Redis if available in Rails cache
-        if defined?(Redis) && Rails.cache.respond_to?(:redis)
-          config.store = ThrottleMachines::Stores::Redis.new(Rails.cache.redis)
-        end
-      end
-    end
+    # No default Rails.cache binding; storage is managed by ThrottleMachines
   end
 end

data/lib/throttle_machines/hedged_breaker.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ThrottleMachines
+  # Hedged request with circuit breaker integration
+  class HedgedBreaker
+    def initialize(breakers, delay: 0.05)
+      @breakers = Array(breakers)
+      @hedged = HedgedRequest.new(
+        delay: delay,
+        max_attempts: @breakers.size
+      )
+    end
+
+    def run(&block)
+      @hedged.run do |attempt|
+        breaker = @breakers[attempt]
+        next if breaker.nil?
+
+        breaker.call(&block)
+      end
+    end
+  end
+end

data/lib/throttle_machines/hedged_request.rb

@@ -94,8 +94,8 @@ module ThrottleMachines
     end
 
     # Run async version
-    def run_async(&)
-      Concurrent::Promises.future { run(&) }
+    def run_async(&block)
+      Concurrent::Promises.future { run(&block) }
     end
 
     # Shutdown the executor
@@ -105,26 +105,6 @@ module ThrottleMachines
     end
   end
 
-  # Hedged request with circuit breaker integration
-  class HedgedBreaker
-    def initialize(breakers, delay: 0.05)
-      @breakers = Array(breakers)
-      @hedged = HedgedRequest.new(
-        delay: delay,
-        max_attempts: @breakers.size
-      )
-    end
-
-    def run(&)
-      @hedged.run do |attempt|
-        breaker = @breakers[attempt]
-        next if breaker.nil?
-
-        breaker.call(&)
-      end
-    end
-  end
-
   # Convenience method
   def self.hedged_request(**, &)
     hedged = HedgedRequest.new(**)

data/lib/throttle_machines/instrumentation.rb

@@ -12,14 +12,10 @@ module ThrottleMachines
       end
 
       def backend
-        @backend ||= if defined?(ActiveSupport::Notifications)
-                       ActiveSupport::Notifications
-                     else
-                       NullBackend.new
-                     end
+        @backend ||= ActiveSupport::Notifications
       end
 
-      def instrument(event_name, payload = {}, &)
+      def instrument(event_name, payload = {}, &block)
         if !enabled || backend.nil?
           return yield if block_given?
 
@@ -27,7 +23,7 @@ module ThrottleMachines
         end
 
         full_event_name = "#{event_name}.throttle_machines"
-        backend.instrument(full_event_name, payload, &)
+        backend.instrument(full_event_name, payload, &block)
       end
 
       # Convenience methods for common events
@@ -70,9 +66,9 @@ module ThrottleMachines
       # Circuit breaker events
       def circuit_opened(breaker, failure_count:)
         payload = {
-          key: breaker.key,
-          failure_threshold: breaker.failure_threshold,
-          timeout: breaker.timeout,
+          key: (breaker.respond_to?(:name) ? breaker.name : breaker.to_s),
+          failure_threshold: (breaker.respond_to?(:configuration) ? breaker.configuration[:failure_threshold] : nil),
+          timeout: (breaker.respond_to?(:configuration) ? breaker.configuration[:reset_timeout] : nil),
           failure_count: failure_count
         }
         instrument('circuit_breaker.opened', payload)
@@ -80,35 +76,35 @@ module ThrottleMachines
 
       def circuit_closed(breaker)
         payload = {
-          key: breaker.key,
-          failure_threshold: breaker.failure_threshold,
-          timeout: breaker.timeout
+          key: (breaker.respond_to?(:name) ? breaker.name : breaker.to_s),
+          failure_threshold: (breaker.respond_to?(:configuration) ? breaker.configuration[:failure_threshold] : nil),
+          timeout: (breaker.respond_to?(:configuration) ? breaker.configuration[:reset_timeout] : nil)
         }
         instrument('circuit_breaker.closed', payload)
       end
 
       def circuit_half_opened(breaker)
         payload = {
-          key: breaker.key,
-          failure_threshold: breaker.failure_threshold,
-          timeout: breaker.timeout,
-          half_open_requests: breaker.half_open_requests
+          key: (breaker.respond_to?(:name) ? breaker.name : breaker.to_s),
+          failure_threshold: (breaker.respond_to?(:configuration) ? breaker.configuration[:failure_threshold] : nil),
+          timeout: (breaker.respond_to?(:configuration) ? breaker.configuration[:reset_timeout] : nil),
+          half_open_requests: (breaker.respond_to?(:configuration) ? breaker.configuration[:half_open_calls] : nil)
         }
         instrument('circuit_breaker.half_opened', payload)
       end
 
       def circuit_success(breaker)
         payload = {
-          key: breaker.key,
-          state: breaker.state
+          key: (breaker.respond_to?(:name) ? breaker.name : breaker.to_s),
+          state: (breaker.respond_to?(:to_h) ? breaker.to_h[:state] : nil)
         }
         instrument('circuit_breaker.success', payload)
       end
 
       def circuit_failure(breaker, error: nil)
         payload = {
-          key: breaker.key,
-          state: breaker.state,
+          key: (breaker.respond_to?(:name) ? breaker.name : breaker.to_s),
+          state: (breaker.respond_to?(:to_h) ? breaker.to_h[:state] : nil),
           error_class: error&.class&.name,
           error_message: error&.message
         }
@@ -117,9 +113,9 @@ module ThrottleMachines
 
       def circuit_rejected(breaker)
         payload = {
-          key: breaker.key,
-          failure_threshold: breaker.failure_threshold,
-          timeout: breaker.timeout
+          key: (breaker.respond_to?(:name) ? breaker.name : breaker.to_s),
+          failure_threshold: (breaker.respond_to?(:configuration) ? breaker.configuration[:failure_threshold] : nil),
+          timeout: (breaker.respond_to?(:configuration) ? breaker.configuration[:reset_timeout] : nil)
         }
         instrument('circuit_breaker.rejected', payload)
       end

data/lib/throttle_machines/middleware.rb

@@ -2,9 +2,8 @@
 
 module ThrottleMachines
   class Middleware
-    def initialize(app, store: nil, &config_block)
+    def initialize(app, &config_block)
       @app = app
-      @store = store || ThrottleMachines.configuration.store
       @rules = []
 
       instance_eval(&config_block) if config_block

data/lib/throttle_machines/rack_middleware/allow2_ban.rb

@@ -34,12 +34,18 @@ module ThrottleMachines
 
         # Check if we've had enough successful requests
         if success_limiter.remaining.zero?
-          # Reset the fail2ban breaker
-          storage = ThrottleMachines.storage
-          storage.reset_breaker(fail_key)
+          # Reset the fail2ban breaker (use BreakerMachines circuit)
+          breaker = BreakerMachines::Registry.instance.get_or_create_dynamic_circuit(
+            fail_key,
+            self,
+            failure_threshold: @maxretry,
+            failure_window: @findtime,
+            reset_timeout: @bantime
+          )
+          breaker.hard_reset
 
           # Reset our own counter
-          storage.reset_counter(success_key, @findtime)
+          ThrottleMachines.storage.reset_counter(success_key, @findtime)
         else
           # Increment success counter
           begin

data/lib/throttle_machines/rack_middleware/configuration.rb

@@ -32,27 +32,27 @@ module ThrottleMachines
       end
 
       # DSL Methods
-      def throttle(name, options = {}, &)
-        @throttles[name] = Throttle.new(name, options, &)
+      def throttle(name, options = {}, &block)
+        @throttles[name] = Throttle.new(name, options, &block)
       end
 
-      def track(name, options = {}, &)
-        @tracks[name] = Track.new(name, options, &)
+      def track(name, options = {}, &block)
+        @tracks[name] = Track.new(name, options, &block)
       end
 
-      def safelist(name = nil, &)
+      def safelist(name = nil, &block)
         if name
-          @safelists[name] = Safelist.new(name, &)
+          @safelists[name] = Safelist.new(name, &block)
         else
-          @anonymous_safelists << Safelist.new(nil, &)
+          @anonymous_safelists << Safelist.new(nil, &block)
         end
       end
 
-      def blocklist(name = nil, &)
+      def blocklist(name = nil, &block)
         if name
-          @blocklists[name] = Blocklist.new(name, &)
+          @blocklists[name] = Blocklist.new(name, &block)
         else
-          @anonymous_blocklists << Blocklist.new(nil, &)
+          @anonymous_blocklists << Blocklist.new(nil, &block)
         end
       end
 
@@ -64,12 +64,12 @@ module ThrottleMachines
         @anonymous_blocklists << Blocklist.new(nil) { |req| req.ip == ip_address }
       end
 
-      def fail2ban(name, options = {}, &)
-        @fail2bans[name] = Fail2Ban.new(name, options, &)
+      def fail2ban(name, options = {}, &block)
+        @fail2bans[name] = Fail2Ban.new(name, options, &block)
       end
 
-      def allow2ban(name, options = {}, &)
-        @allow2bans[name] = Allow2Ban.new(name, options, &)
+      def allow2ban(name, options = {}, &block)
+        @allow2bans[name] = Allow2Ban.new(name, options, &block)
       end
 
       # Check methods

data/lib/throttle_machines/rack_middleware/fail2_ban.rb

@@ -20,18 +20,25 @@ module ThrottleMachines
 
         key = "fail2ban:#{@name}:#{discriminator}"
 
-        # Use circuit breaker to track failures
-        breaker = ThrottleMachines::Breaker.new(
+        # Use a globally managed BreakerMachines circuit as the ban mechanism
+        breaker = BreakerMachines::Registry.instance.get_or_create_dynamic_circuit(
           key,
+          self,
           failure_threshold: @maxretry,
-          timeout: @bantime,
-          storage: ThrottleMachines.storage
+          failure_window: @findtime,
+          reset_timeout: @bantime
         )
 
         # Check if circuit is open (banned)
         if breaker.open?
-          # Get breaker state for instrumentation
-          state = breaker.to_h
+          stats = breaker.stats
+          now = BreakerMachines.monotonic_time
+          time_until_unban = if stats.opened_at
+                               remaining = @bantime - (now - stats.opened_at)
+                               remaining.positive? ? remaining : 0
+                             else
+                               @bantime
+                             end
 
           request.env['rack.attack.matched'] = @name
           request.env['rack.attack.match_type'] = :fail2ban
@@ -41,8 +48,8 @@ module ThrottleMachines
             maxretry: @maxretry,
             findtime: @findtime,
             bantime: @bantime,
-            failures: state[:failure_count],
-            time_until_unban: state[:time_until_retry]
+            failures: stats.failure_count,
+            time_until_unban: time_until_unban
           }
 
           ThrottleMachines::RackMiddleware.instrument(request)
@@ -61,11 +68,12 @@ module ThrottleMachines
         # Use the breaker to record a failure if block returns true
         return unless yield
 
-        breaker = ThrottleMachines::Breaker.new(
+        breaker = BreakerMachines::Registry.instance.get_or_create_dynamic_circuit(
           key,
+          self,
           failure_threshold: @maxretry,
-          timeout: @bantime,
-          storage: ThrottleMachines.storage
+          failure_window: @findtime,
+          reset_timeout: @bantime
         )
 
         # Record failure by trying to call through the breaker

data/lib/throttle_machines/rack_middleware.rb

@@ -30,14 +30,16 @@ module ThrottleMachines
                      :safelists,
                      :blocklists
 
-      def configure(&)
+      def configure(&block)
         @configuration ||= Configuration.new
-        @configuration.instance_eval(&) if block
+        @configuration.instance_eval(&block) if block
       end
 
+      # rubocop:disable Rails/Delegate -- Ruby 3.4 compatibility issue with delegate
       def reset!
         ThrottleMachines.reset!
       end
+      # rubocop:enable Rails/Delegate
 
       def clear!
         @configuration = Configuration.new
@@ -54,7 +56,7 @@ module ThrottleMachines
 
     # Set defaults
     @enabled = true
-    @notifier = ActiveSupport::Notifications if defined?(ActiveSupport::Notifications)
+    @notifier = ActiveSupport::Notifications
     @configuration = Configuration.new
 
     def initialize(app)

data/lib/throttle_machines/storage/base.rb

@@ -42,27 +42,6 @@ module ThrottleMachines
         raise NotImplementedError
       end
 
-      # Circuit breaker operations
-      def get_breaker_state(key)
-        raise NotImplementedError
-      end
-
-      def record_breaker_success(key, timeout, half_open_requests = 1)
-        raise NotImplementedError
-      end
-
-      def record_breaker_failure(key, threshold, timeout)
-        raise NotImplementedError
-      end
-
-      def trip_breaker(key, timeout)
-        raise NotImplementedError
-      end
-
-      def reset_breaker(key)
-        raise NotImplementedError
-      end
-
       # Utility operations
       def clear(pattern = nil)
         raise NotImplementedError
@@ -72,8 +51,8 @@ module ThrottleMachines
         raise NotImplementedError
       end
 
-      def with_timeout(timeout, &)
-        Timeout.timeout(timeout, &)
+      def with_timeout(timeout, &block)
+        Timeout.timeout(timeout, &block)
       rescue Timeout::Error
         nil
       end

data/lib/throttle_machines/storage/memory.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
 require 'concurrent'
 
 module ThrottleMachines
@@ -11,7 +10,6 @@ module ThrottleMachines
         @counters = Concurrent::Hash.new
         @gcra_states = Concurrent::Hash.new
         @token_buckets = Concurrent::Hash.new
-        @breaker_states = Concurrent::Hash.new
 
         # Use a striped lock pattern - pool of locks for fine-grained concurrency
         @lock_pool_size = options[:lock_pool_size] || 32
@@ -181,98 +179,7 @@ module ThrottleMachines
         end
       end
 
-      # Circuit breaker operations
-      def get_breaker_state(key)
-        # First try with read lock
-        state = with_read_lock("breaker:#{key}") do
-          @breaker_states[key] || { state: :closed, failures: 0, last_failure: nil }
-        end
-
-        # Check if we need to transition from open to half-open
-        if state[:state] == :open && state[:opens_at] && current_time >= state[:opens_at]
-          # Release read lock and acquire write lock
-          with_write_lock("breaker:#{key}") do
-            # Re-check condition after acquiring write lock
-            current_state = @breaker_states[key]
-            if current_state && current_state[:state] == :open && current_state[:opens_at] && current_time >= current_state[:opens_at]
-              @breaker_states[key] = current_state.merge(
-                state: :half_open,
-                half_open_attempts: 0
-              )
-            end
-            @breaker_states[key] || { state: :closed, failures: 0, last_failure: nil }
-          end
-        else
-          state
-        end
-      end
-
-      def record_breaker_success(key, _timeout, half_open_requests = 1)
-        with_write_lock("breaker:#{key}") do
-          state = @breaker_states[key]
-          return unless state
-
-          case state[:state]
-          when :half_open
-            attempts = (state[:half_open_attempts] || 0) + 1
-            if attempts >= half_open_requests
-              @breaker_states.delete(key)
-            else
-              @breaker_states[key] = state.merge(half_open_attempts: attempts)
-            end
-          when :closed
-            # Reset failure count on success
-            @breaker_states[key] = state.merge(failures: 0) if state[:failures].positive?
-          end
-        end
-      end
-
-      def record_breaker_failure(key, threshold, timeout)
-        with_write_lock("breaker:#{key}") do
-          state = @breaker_states[key] || { state: :closed, failures: 0 }
-          now = current_time
-
-          case state[:state]
-          when :closed
-            failures = state[:failures] + 1
-            @breaker_states[key] = if failures >= threshold
-                                     {
-                                       state: :open,
-                                       failures: failures,
-                                       last_failure: now,
-                                       opens_at: now + timeout
-                                     }
-                                   else
-                                     state.merge(failures: failures, last_failure: now)
-                                   end
-          when :half_open
-            @breaker_states[key] = {
-              state: :open,
-              failures: state[:failures],
-              last_failure: now,
-              opens_at: now + timeout
-            }
-          end
-
-          @breaker_states[key]
-        end
-      end
-
-      def trip_breaker(key, timeout)
-        with_write_lock("breaker:#{key}") do
-          now = current_time
-          @breaker_states[key] = {
-            state: :open,
-            failures: 0,
-            last_failure: now,
-            opens_at: now + timeout
-          }
-        end
-      end
-
-      def reset_breaker(key)
-        with_write_lock("breaker:#{key}") { @breaker_states.delete(key) }
-      end
+      # No circuit breaker operations here: breaker state is owned by BreakerMachines
 
       # Utility operations
       def clear(pattern = nil)
@@ -280,7 +187,7 @@ module ThrottleMachines
           regex = Regexp.new(pattern.gsub('*', '.*'))
 
           # Clear matching keys from all stores
-          [@counters, @gcra_states, @token_buckets, @breaker_states].each do |store|
+          [@counters, @gcra_states, @token_buckets].each do |store|
             store.each_key do |k|
               store.delete(k) if k&.match?(regex)
             end
@@ -289,7 +196,6 @@ module ThrottleMachines
           @counters.clear
           @gcra_states.clear
           @token_buckets.clear
-          @breaker_states.clear
         end
       end
 
@@ -306,12 +212,12 @@ module ThrottleMachines
 
       private
 
-      def with_read_lock(key, &)
-        lock_for(key).with_read_lock(&)
+      def with_read_lock(key, &block)
+        lock_for(key).with_read_lock(&block)
       end
 
-      def with_write_lock(key, &)
-        lock_for(key).with_write_lock(&)
+      def with_write_lock(key, &block)
+        lock_for(key).with_write_lock(&block)
       end
 
       def lock_for(key)
@@ -351,20 +257,7 @@ module ThrottleMachines
           with_write_lock(key) { @token_buckets.delete(key) } if data[:expires_at] && data[:expires_at] <= now
         end
 
-        # Clean closed breaker states and expired open states
-        @breaker_states.each_pair do |key, data|
-          should_delete = false
-
-          # Clean closed states that have been idle
-          should_delete = true if data[:state] == :closed && data[:failures].zero?
-
-          # Clean expired open states (older than 2x timeout)
-          if data[:opens_at] && now > data[:opens_at] + ((data[:opens_at] - (data[:last_failure] || now)) * 2)
-            should_delete = true
-          end
-
-          with_write_lock("breaker:#{key}") { @breaker_states.delete(key) } if should_delete
-        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}"

data/lib/throttle_machines/storage/null.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 module ThrottleMachines
   module Storage
     class Null < Base
@@ -56,27 +54,6 @@ module ThrottleMachines
         }
       end
 
-      # Circuit breaker operations
-      def get_breaker_state(_key)
-        { state: :closed, failures: 0, last_failure: nil }
-      end
-
-      def record_breaker_success(_key, _timeout, _half_open_requests = 1)
-        true
-      end
-
-      def record_breaker_failure(_key, _threshold, _timeout)
-        { state: :closed, failures: 0, last_failure: nil }
-      end
-
-      def trip_breaker(_key, _timeout)
-        true
-      end
-
-      def reset_breaker(_key)
-        true
-      end
-
       # Utility operations
       def clear(_pattern = nil)
         true

data/lib/throttle_machines/storage/redis/gcra.lua

@@ -0,0 +1,22 @@
+local key = KEYS[1]
+local emission_interval = tonumber(ARGV[1])
+local delay_tolerance = tonumber(ARGV[2])
+local ttl = tonumber(ARGV[3])
+local now = tonumber(ARGV[4])
+
+local tat = redis.call('GET', key)
+if not tat then
+  tat = 0
+else
+  tat = tonumber(tat)
+end
+
+tat = math.max(tat, now)
+local allow = (tat - now) <= delay_tolerance
+
+if allow then
+  local new_tat = tat + emission_interval
+  redis.call('SET', key, new_tat, 'EX', ttl)
+end
+
+return { allow and 1 or 0, tat }

data/lib/throttle_machines/storage/redis/increment_counter.lua

@@ -0,0 +1,9 @@
+local count = redis.call('INCRBY', KEYS[1], ARGV[1])
+local ttl = redis.call('TTL', KEYS[1])
+
+-- Set expiry if key is new (ttl == -2) or has no TTL (ttl == -1)
+if ttl <= 0 then
+  redis.call('EXPIRE', KEYS[1], ARGV[2])
+end
+
+return count

data/lib/throttle_machines/storage/redis/peek_gcra.lua

@@ -0,0 +1,16 @@
+local key = KEYS[1]
+local emission_interval = tonumber(ARGV[1])
+local delay_tolerance = tonumber(ARGV[2])
+local now = tonumber(ARGV[3])
+
+local tat = redis.call('GET', key)
+if not tat then
+  tat = 0
+else
+  tat = tonumber(tat)
+end
+
+tat = math.max(tat, now)
+local allow = (tat - now) <= delay_tolerance
+
+return { allow and 1 or 0, tat }

data/lib/throttle_machines/storage/redis/peek_token_bucket.lua

@@ -0,0 +1,18 @@
+local key = KEYS[1]
+local capacity = tonumber(ARGV[1])
+local refill_rate = tonumber(ARGV[2])
+local now = tonumber(ARGV[3])
+
+local bucket = redis.call('HMGET', key, 'tokens', 'last_refill')
+local tokens = tonumber(bucket[1]) or capacity
+local last_refill = tonumber(bucket[2]) or now
+
+-- Calculate tokens without modifying
+local elapsed = now - last_refill
+local tokens_to_add = elapsed * refill_rate
+tokens = math.min(tokens + tokens_to_add, capacity)
+
+local allow = tokens >= 1
+local tokens_after = allow and (tokens - 1) or 0
+
+return { allow and 1 or 0, tokens_after }

data/lib/throttle_machines/storage/redis/token_bucket.lua

@@ -0,0 +1,23 @@
+local key = KEYS[1]
+local capacity = tonumber(ARGV[1])
+local refill_rate = tonumber(ARGV[2])
+local ttl = tonumber(ARGV[3])
+local now = tonumber(ARGV[4])
+
+local bucket = redis.call('HMGET', key, 'tokens', 'last_refill')
+local tokens = tonumber(bucket[1]) or capacity
+local last_refill = tonumber(bucket[2]) or now
+
+-- Refill tokens
+local elapsed = now - last_refill
+local tokens_to_add = elapsed * refill_rate
+tokens = math.min(tokens + tokens_to_add, capacity)
+
+local allow = tokens >= 1
+if allow then
+  tokens = tokens - 1
+  redis.call('HMSET', key, 'tokens', tokens, 'last_refill', now)
+  redis.call('EXPIRE', key, ttl)
+end
+
+return { allow and 1 or 0, tokens }

data/lib/throttle_machines/storage/redis.rb

@@ -1,100 +1,17 @@
 # frozen_string_literal: true
 
-require_relative 'base'
-
 module ThrottleMachines
   module Storage
     class Redis < Base
-      GCRA_SCRIPT = <<~LUA
-        local key = KEYS[1]
-        local emission_interval = tonumber(ARGV[1])
-        local delay_tolerance = tonumber(ARGV[2])
-        local ttl = tonumber(ARGV[3])
-        local now = tonumber(ARGV[4])
-
-        local tat = redis.call('GET', key)
-        if not tat then
-          tat = 0
-        else
-          tat = tonumber(tat)
-        end
-
-        tat = math.max(tat, now)
-        local allow = (tat - now) <= delay_tolerance
-
-        if allow then
-          local new_tat = tat + emission_interval
-          redis.call('SET', key, new_tat, 'EX', ttl)
-        end
-
-        return { allow and 1 or 0, tat }
-      LUA
-
-      TOKEN_BUCKET_SCRIPT = <<~LUA
-        local key = KEYS[1]
-        local capacity = tonumber(ARGV[1])
-        local refill_rate = tonumber(ARGV[2])
-        local ttl = tonumber(ARGV[3])
-        local now = tonumber(ARGV[4])
-
-        local bucket = redis.call('HMGET', key, 'tokens', 'last_refill')
-        local tokens = tonumber(bucket[1]) or capacity
-        local last_refill = tonumber(bucket[2]) or now
-
-        -- Refill tokens
-        local elapsed = now - last_refill
-        local tokens_to_add = elapsed * refill_rate
-        tokens = math.min(tokens + tokens_to_add, capacity)
-
-        local allow = tokens >= 1
-        if allow then
-          tokens = tokens - 1
-          redis.call('HMSET', key, 'tokens', tokens, 'last_refill', now)
-          redis.call('EXPIRE', key, ttl)
-        end
-
-        return { allow and 1 or 0, tokens }
-      LUA
-
-      PEEK_GCRA_SCRIPT = <<~LUA
-        local key = KEYS[1]
-        local emission_interval = tonumber(ARGV[1])
-        local delay_tolerance = tonumber(ARGV[2])
-        local now = tonumber(ARGV[3])
-
-        local tat = redis.call('GET', key)
-        if not tat then
-          tat = 0
-        else
-          tat = tonumber(tat)
-        end
+      # Load Lua scripts from files
+      LUA_SCRIPTS_DIR = File.expand_path('redis', __dir__)
 
-        tat = math.max(tat, now)
-        local allow = (tat - now) <= delay_tolerance
-
-        return { allow and 1 or 0, tat }
-      LUA
-
-      PEEK_TOKEN_BUCKET_SCRIPT = <<~LUA
-        local key = KEYS[1]
-        local capacity = tonumber(ARGV[1])
-        local refill_rate = tonumber(ARGV[2])
-        local now = tonumber(ARGV[3])
-
-        local bucket = redis.call('HMGET', key, 'tokens', 'last_refill')
-        local tokens = tonumber(bucket[1]) or capacity
-        local last_refill = tonumber(bucket[2]) or now
-
-        -- Calculate tokens without modifying
-        local elapsed = now - last_refill
-        local tokens_to_add = elapsed * refill_rate
-        tokens = math.min(tokens + tokens_to_add, capacity)
-
-        local allow = tokens >= 1
-        local tokens_after = allow and (tokens - 1) or 0
-
-        return { allow and 1 or 0, tokens_after }
-      LUA
+      GCRA_SCRIPT = File.read(File.join(LUA_SCRIPTS_DIR, 'gcra.lua'))
+      TOKEN_BUCKET_SCRIPT = File.read(File.join(LUA_SCRIPTS_DIR, 'token_bucket.lua'))
+      PEEK_GCRA_SCRIPT = File.read(File.join(LUA_SCRIPTS_DIR, 'peek_gcra.lua'))
+      PEEK_TOKEN_BUCKET_SCRIPT = File.read(File.join(LUA_SCRIPTS_DIR, 'peek_token_bucket.lua'))
+      INCREMENT_COUNTER_SCRIPT = File.read(File.join(LUA_SCRIPTS_DIR, 'increment_counter.lua'))
+      # Breaker scripts removed: breaker state is owned by BreakerMachines
 
       def initialize(options = {})
         super
@@ -117,17 +34,7 @@ module ThrottleMachines
 
         # Use Lua script for atomic increment with TTL
         with_redis do |redis|
-          redis.eval(<<~LUA, keys: [window_key], argv: [amount, window.to_i])
-            local count = redis.call('INCRBY', KEYS[1], ARGV[1])
-            local ttl = redis.call('TTL', KEYS[1])
-
-            -- Set expiry if key is new (ttl == -2) or has no TTL (ttl == -1)
-            if ttl <= 0 then
-              redis.call('EXPIRE', KEYS[1], ARGV[2])
-            end
-
-            return count
-          LUA
+          redis.eval(INCREMENT_COUNTER_SCRIPT, keys: [window_key], argv: [amount, window.to_i])
         end
       end
 
@@ -256,134 +163,7 @@ module ThrottleMachines
         retry
       end
 
-      # Circuit breaker operations
-      def get_breaker_state(key)
-        breaker_key = prefixed("breaker:#{key}")
-
-        # Use Lua script for atomic read and potential state transition
-        result = with_redis do |redis|
-          redis.eval(<<~LUA, keys: [breaker_key], argv: [current_time])
-            local data = redis.call('HGETALL', KEYS[1])
-            if #data == 0 then
-              return {}
-            end
-
-            local state = {}
-            for i = 1, #data, 2 do
-              state[data[i]] = data[i + 1]
-            end
-
-            -- Auto-transition from open to half-open if timeout passed
-            if state['state'] == 'open' and state['opens_at'] then
-              local now = tonumber(ARGV[1])
-              local opens_at = tonumber(state['opens_at'])
-            #{'  '}
-              if now >= opens_at then
-                redis.call('HSET', KEYS[1], 'state', 'half_open', 'half_open_attempts', '0')
-                state['state'] = 'half_open'
-                state['half_open_attempts'] = '0'
-              end
-            end
-
-            return state
-          LUA
-        end
-
-        return { state: :closed, failures: 0, last_failure: nil } if result.empty?
-
-        # Convert hash from Lua to Ruby format
-        state = {}
-        result.each_slice(2) { |k, v| state[k] = v }
-
-        {
-          state: state['state'].to_sym,
-          failures: state['failures'].to_i,
-          last_failure: state['last_failure']&.to_f,
-          opens_at: state['opens_at']&.to_f,
-          half_open_attempts: state['half_open_attempts']&.to_i
-        }
-      end
-
-      def record_breaker_success(key, _timeout, half_open_requests = 1)
-        breaker_key = prefixed("breaker:#{key}")
-
-        # Use Lua script for atomic success recording
-        with_redis do |redis|
-          redis.eval(<<~LUA, keys: [breaker_key], argv: [half_open_requests])
-            local state = redis.call('HGET', KEYS[1], 'state')
-
-            if state == 'half_open' then
-              -- Increment half-open attempts and potentially close the circuit
-              local attempts = redis.call('HINCRBY', KEYS[1], 'half_open_attempts', 1)
-            #{'  '}
-              if attempts >= tonumber(ARGV[1]) then
-                redis.call('DEL', KEYS[1])
-              end
-            elseif state == 'closed' then
-              -- Reset failure count on success in closed state
-              local failures = redis.call('HGET', KEYS[1], 'failures')
-              if failures and tonumber(failures) > 0 then
-                redis.call('HSET', KEYS[1], 'failures', 0)
-              end
-            end
-          LUA
-        end
-      end
-
-      def record_breaker_failure(key, threshold, timeout)
-        breaker_key = prefixed("breaker:#{key}")
-        now = current_time
-
-        # Use Lua script for atomic failure recording
-        with_redis do |redis|
-          redis.eval(<<~LUA, keys: [breaker_key], argv: [threshold, timeout, now])
-            local state = redis.call('HGET', KEYS[1], 'state') or 'closed'
-            local now = ARGV[3]
-            local timeout = tonumber(ARGV[2])
-
-            if state == 'half_open' then
-              -- Failure in half-open state, just re-open the circuit
-              redis.call('HMSET', KEYS[1],
-                'state', 'open',
-                'opens_at', tonumber(now) + timeout,
-                'last_failure', now
-              )
-            else -- state is 'closed' or nil
-              local failures = redis.call('HINCRBY', KEYS[1], 'failures', 1)
-              redis.call('HSET', KEYS[1], 'last_failure', now)
-            #{'  '}
-              if failures >= tonumber(ARGV[1]) then
-                redis.call('HMSET', KEYS[1],
-                  'state', 'open',
-                  'opens_at', tonumber(now) + timeout
-                )
-              end
-            end
-
-            redis.call('EXPIRE', KEYS[1], timeout * 2)
-          LUA
-        end
-
-        get_breaker_state(key)
-      end
-
-      def trip_breaker(key, timeout)
-        breaker_key = prefixed("breaker:#{key}")
-        now = current_time
-
-        with_redis do |redis|
-          redis.hmset(breaker_key,
-                      'state', 'open',
-                      'failures', 0,
-                      'last_failure', now,
-                      'opens_at', now + timeout)
-          redis.expire(breaker_key, (timeout * 2).to_i)
-        end
-      end
-
-      def reset_breaker(key)
-        with_redis { |r| r.del(prefixed("breaker:#{key}")) }
-      end
+      # No circuit breaker operations: breaker state is owned by BreakerMachines
 
       # Utility operations
       def clear(pattern = nil)
@@ -437,13 +217,13 @@ module ThrottleMachines
         raise ArgumentError, "Invalid Redis connection: #{e.message}"
       end
 
-      def with_redis(&)
+      def with_redis(&block)
         if @redis.respond_to?(:with)
           # Connection pool
-          @redis.with(&)
+          @redis.with(&block)
         else
           # Regular Redis client
-          yield @redis
+          block.call(@redis)
         end
       end
     end

data/lib/throttle_machines/version.rb

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

data/lib/throttle_machines.rb

@@ -3,7 +3,7 @@
 require 'json'
 require 'timeout'
 require 'zeitwerk'
-require 'active_support/configurable'
+require 'active_support/core_ext/class/attribute'
 
 # Ecosystem dependencies
 require 'chrono_machines'
@@ -14,25 +14,32 @@ loader = Zeitwerk::Loader.for_gem
 loader.ignore("#{__dir__}/throttle_machines/engine.rb") unless defined?(Rails::Engine)
 loader.setup
 
-# Load conditional dependencies manually
-require_relative 'throttle_machines/storage/redis' if defined?(Redis)
-
 module ThrottleMachines
-  include ActiveSupport::Configurable
+  class Configuration
+    attr_accessor :default_limit, :default_period, :default_storage, :clock,
+                  :instrumentation_enabled, :instrumentation_backend, :_storage_instance
+
+    def initialize
+      @default_limit = 100
+      @default_period = 60 # 1 minute
+      @default_storage = :memory
+      @clock = nil
+      @instrumentation_enabled = true
+      @instrumentation_backend = nil
+      @_storage_instance = nil
+    end
+  end
 
-  # Define configuration options with defaults
-  config_accessor :default_limit, default: 100
-  config_accessor :default_period, default: 60 # 1 minute
-  config_accessor :default_storage, default: :memory
-  config_accessor :clock, default: nil
-  config_accessor :instrumentation_enabled, default: true
-  config_accessor :instrumentation_backend
-  config_accessor :_storage_instance
+  @config = Configuration.new
 
   class << self
     # Delegate monotonic time to BreakerMachines for consistency
     delegate :monotonic_time, to: :BreakerMachines
 
+    def config
+      @config
+    end
+
     def configure
       yield(config) if block_given?
 
@@ -68,28 +75,28 @@ module ThrottleMachines
       control
     end
 
-    def limit(key, limit:, period:, algorithm: :fixed_window, &)
+    def limit(key, limit:, period:, algorithm: :fixed_window, &block)
       limiter = limiter(key, limit: limit, period: period, algorithm: algorithm)
-      limiter.throttle!(&)
+      limiter.throttle!(&block)
     end
 
-    def break_circuit(key, failures:, timeout:, &)
-      # Delegate to breaker_machines
+    def break_circuit(key, failures:, timeout:, &block)
+      # Delegate to BreakerMachines; use reset_timeout for open duration
       breaker = BreakerMachines::Circuit.new(
-        key: key,
+        key,
         failure_threshold: failures,
-        timeout: timeout
+        reset_timeout: timeout
       )
-      breaker.call(&)
+      breaker.call(&block)
     end
 
-    def retry_with(max_attempts: 3, backoff: :exponential, &)
+    def retry_with(max_attempts: 3, backoff: :exponential, &block)
       # Delegate to chrono_machines
       policy_options = {
         max_attempts: max_attempts,
         jitter_factor: backoff == :exponential ? 1.0 : 0.0
       }
-      ChronoMachines.retry(policy_options, &)
+      ChronoMachines.retry(policy_options, &block)
     end
 
     def limiter(key, limit:, period:, algorithm: :fixed_window)
@@ -132,7 +139,9 @@ module ThrottleMachines
   # Auto-configure with defaults
   configure
 
-  # Backward compatibility aliases for error classes (defined after module setup)
-  CircuitOpenError = BreakerMachines::CircuitOpenError if defined?(BreakerMachines::CircuitOpenError)
-  RetryExhaustedError = ChronoMachines::MaxRetriesExceededError if defined?(ChronoMachines::MaxRetriesExceededError)
+  CircuitOpenError = BreakerMachines::CircuitOpenError
+  RetryExhaustedError = ChronoMachines::MaxRetriesExceededError
+
+  # Back-compat wrapper: use BreakerMachines as the circuit implementation
+  Breaker = BreakerMachines::Circuit
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: throttle_machines
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: 8.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: 8.0.4
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: chrono_machines
   requirement: !ruby/object:Gem::Requirement
@@ -101,16 +101,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- MIT-LICENSE
+- LICENSE
 - README.md
 - Rakefile
 - lib/throttle_machines.rb
 - lib/throttle_machines/async_limiter.rb
-- lib/throttle_machines/clock.rb
 - lib/throttle_machines/control.rb
 - lib/throttle_machines/controller_helpers.rb
 - lib/throttle_machines/dependency_error.rb
 - lib/throttle_machines/engine.rb
+- lib/throttle_machines/hedged_breaker.rb
 - lib/throttle_machines/hedged_request.rb
 - lib/throttle_machines/instrumentation.rb
 - lib/throttle_machines/limiter.rb
@@ -128,6 +128,11 @@ files:
 - lib/throttle_machines/storage/memory.rb
 - lib/throttle_machines/storage/null.rb
 - lib/throttle_machines/storage/redis.rb
+- lib/throttle_machines/storage/redis/gcra.lua
+- lib/throttle_machines/storage/redis/increment_counter.lua
+- lib/throttle_machines/storage/redis/peek_gcra.lua
+- lib/throttle_machines/storage/redis/peek_token_bucket.lua
+- lib/throttle_machines/storage/redis/token_bucket.lua
 - lib/throttle_machines/throttled_error.rb
 - lib/throttle_machines/version.rb
 homepage: https://github.com/seuros/throttle_machines

data/lib/throttle_machines/clock.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module ThrottleMachines
-  # TestClock for time manipulation in tests
-  # This overrides the global monotonic_time method for testing
-  class TestClock
-    attr_accessor :current_time
-
-    def initialize(start_time = Time.now.to_f)
-      @current_time = start_time
-      
-      # Override the global monotonic_time method
-      ThrottleMachines.singleton_class.define_method(:monotonic_time) do
-        @current_time
-      end
-    end
-
-    def now
-      @current_time
-    end
-
-    def monotonic
-      @current_time
-    end
-
-    def advance(seconds)
-      @current_time += seconds
-    end
-
-    def travel_to(time)
-      @current_time = time.to_f
-    end
-
-    def reset
-      # Restore the original monotonic_time method
-      ThrottleMachines.singleton_class.define_method(:monotonic_time) do
-        BreakerMachines.monotonic_time
-      end
-    end
-  end
-end