throttle_machines 0.1.1 → 0.2.4

data/lib/throttle_machines/rack_middleware/fail2_ban.rb

@@ -2,36 +2,32 @@
 
 module ThrottleMachines
   class RackMiddleware
-    class Fail2Ban
-      attr_reader :name, :maxretry, :findtime, :bantime, :block
-
-      def initialize(name, options, &block)
-        @name = name
-        @block = block
-
-        @maxretry = options[:maxretry] || 5
-        @findtime = options[:findtime] || 60
-        @bantime = options[:bantime] || 300
-      end
-
+    class Fail2Ban < BanFilter
       def banned?(request)
         discriminator = discriminator_for(request)
         return false unless discriminator
 
         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 +37,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 +57,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
@@ -76,12 +73,6 @@ module ThrottleMachines
           # Expected - this records the failure
         end
       end
-
-      private
-
-      def discriminator_for(request)
-        @block.call(request)
-      end
     end
   end
 end

data/lib/throttle_machines/rack_middleware/list_filter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ThrottleMachines
+  class RackMiddleware
+    # Base class for Safelist and Blocklist filters.
+    #
+    # Both match a request against a user-supplied block and, on a match, tag the
+    # rack env and emit instrumentation. They differ only in the +match_type+
+    # recorded on the env, which subclasses provide.
+    class ListFilter
+      attr_reader :name, :block
+
+      def initialize(name, &block)
+        @name = name
+        @block = block
+      end
+
+      def matched_by?(request)
+        return false unless @block
+
+        if @block.call(request)
+          request.env['rack.attack.matched'] = @name
+          request.env['rack.attack.match_type'] = match_type
+          ThrottleMachines::RackMiddleware.instrument(request)
+          true
+        else
+          false
+        end
+      end
+
+      private
+
+      # @return [Symbol] the rack.attack match type recorded for this filter
+      def match_type
+        raise NotImplementedError, "#{self.class} must implement #match_type"
+      end
+    end
+  end
+end

data/lib/throttle_machines/rack_middleware/safelist.rb

@@ -2,25 +2,12 @@
 
 module ThrottleMachines
   class RackMiddleware
-    class Safelist
-      attr_reader :name, :block
+    # Allows (short-circuits) requests matching the configured block.
+    class Safelist < ListFilter
+      private
 
-      def initialize(name, &block)
-        @name = name
-        @block = block
-      end
-
-      def matched_by?(request)
-        return false unless @block
-
-        if @block.call(request)
-          request.env['rack.attack.matched'] = @name
-          request.env['rack.attack.match_type'] = :safelist
-          ThrottleMachines::RackMiddleware.instrument(request)
-          true
-        else
-          false
-        end
+      def match_type
+        :safelist
       end
     end
   end

data/lib/throttle_machines/rack_middleware.rb

@@ -30,16 +30,14 @@ 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

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

@@ -10,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
@@ -180,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)
@@ -279,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
@@ -288,7 +196,6 @@ module ThrottleMachines
           @counters.clear
           @gcra_states.clear
           @token_buckets.clear
-          @breaker_states.clear
         end
       end
 
@@ -305,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)
@@ -350,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

@@ -54,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

@@ -19,4 +19,4 @@ if allow then
   redis.call('SET', key, new_tat, 'EX', ttl)
 end
 
-return { allow and 1 or 0, tat }
+return { allow and 1 or 0, tat }

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

@@ -6,4 +6,4 @@ if ttl <= 0 then
   redis.call('EXPIRE', KEYS[1], ARGV[2])
 end
 
-return count
+return count

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

@@ -13,4 +13,4 @@ end
 tat = math.max(tat, now)
 local allow = (tat - now) <= delay_tolerance
 
-return { allow and 1 or 0, tat }
+return { allow and 1 or 0, tat }

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

@@ -15,4 +15,4 @@ 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 }
+return { allow and 1 or 0, tokens_after }

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

@@ -20,4 +20,4 @@ if allow then
   redis.call('EXPIRE', key, ttl)
 end
 
-return { allow and 1 or 0, tokens }
+return { allow and 1 or 0, tokens }

data/lib/throttle_machines/storage/redis.rb

@@ -11,9 +11,7 @@ module ThrottleMachines
       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'))
-      GET_BREAKER_STATE_SCRIPT = File.read(File.join(LUA_SCRIPTS_DIR, 'get_breaker_state.lua'))
-      RECORD_BREAKER_SUCCESS_SCRIPT = File.read(File.join(LUA_SCRIPTS_DIR, 'record_breaker_success.lua'))
-      RECORD_BREAKER_FAILURE_SCRIPT = File.read(File.join(LUA_SCRIPTS_DIR, 'record_breaker_failure.lua'))
+      # Breaker scripts removed: breaker state is owned by BreakerMachines
 
       def initialize(options = {})
         super
@@ -165,68 +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(GET_BREAKER_STATE_SCRIPT, keys: [breaker_key], argv: [current_time])
-        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(RECORD_BREAKER_SUCCESS_SCRIPT, keys: [breaker_key], argv: [half_open_requests])
-        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(RECORD_BREAKER_FAILURE_SCRIPT, keys: [breaker_key], argv: [threshold, timeout, now])
-        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)
@@ -280,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.1'
+  VERSION = '0.2.4'
 end