throttle_machines 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c498f9f097c1eac7384d573ea5e90b04e3850d6b236aae5a0f5b9bb0cdf29ae
-  data.tar.gz: 515fae0aad7083290b12cec368148e021ff9312fb026892fb4574fd89a1a0f6c
+  metadata.gz: ff1906a9e597bee94979f637bf351aa53160ec2b349005ed731069bdb85cd032
+  data.tar.gz: 2293e5d59855593686cc2a8df0df560c5286452bc63bbcea4e13fca04d824c92
 SHA512:
-  metadata.gz: ec8ac810c8696a93a44bcf305245eef336ce338418b82a5236e73fa919afda7125cee2ac391c0230419f136525ee1104723dc3a81e42517c4c0a48ebd6878d76
-  data.tar.gz: 3908d0866286abc0556b79160c8543da2b542ab3cfb55b2c2d636fc69bb0393196848f920714e89e4926d7e4450ae5de33329d0774ae4a0f8f59860bbbaad620
+  metadata.gz: 7c1fa93375186f6036c1efcba1292207ba0c831ee0d5e5bb73b7c985e2d45b3c52362d79d590ad1904a25568040e00e5929373381fb48da57155a646e8588e24
+  data.tar.gz: ae5ffa6881f0e7913227de2991ae8ffd17af31525040e43741491691cddde6ee8e4d27a9a2ad5dd5d2537335237e008f3397e9c4d3f45fab123cdac850ee7c73

data/lib/throttle_machines/controller_helpers.rb

@@ -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,11 +13,6 @@ module ThrottleMachines
       end
     end
 
-    initializer 'throttle_machines.configure_defaults' do |_app|
-      ThrottleMachines.configure do |config|
-        # Use Rails.cache , user can override
-        config.store = Rails.cache
-      end
-    end
+    # No default Rails.cache binding; storage is managed by ThrottleMachines
   end
 end

data/lib/throttle_machines/hedged_breaker.rb

@@ -11,12 +11,12 @@ module ThrottleMachines
       )
     end
 
-    def run(&)
+    def run(&block)
       @hedged.run do |attempt|
         breaker = @breakers[attempt]
         next if breaker.nil?
 
-        breaker.call(&)
+        breaker.call(&block)
       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

data/lib/throttle_machines/instrumentation.rb

@@ -15,7 +15,7 @@ module ThrottleMachines
         @backend ||= ActiveSupport::Notifications
       end
 
-      def instrument(event_name, payload = {}, &)
+      def instrument(event_name, payload = {}, &block)
         if !enabled || backend.nil?
           return yield if block_given?
 
@@ -23,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
@@ -66,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)
@@ -76,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
         }
@@ -113,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,9 +30,9 @@ 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

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.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.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'
@@ -15,21 +15,31 @@ loader.ignore("#{__dir__}/throttle_machines/engine.rb") unless defined?(Rails::E
 loader.setup
 
 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?
 
@@ -65,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)
@@ -131,4 +141,7 @@ module ThrottleMachines
 
   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.1
+  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
@@ -129,12 +129,9 @@ files:
 - lib/throttle_machines/storage/null.rb
 - lib/throttle_machines/storage/redis.rb
 - lib/throttle_machines/storage/redis/gcra.lua
-- lib/throttle_machines/storage/redis/get_breaker_state.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/record_breaker_failure.lua
-- lib/throttle_machines/storage/redis/record_breaker_success.lua
 - lib/throttle_machines/storage/redis/token_bucket.lua
 - lib/throttle_machines/throttled_error.rb
 - lib/throttle_machines/version.rb

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

@@ -1,23 +0,0 @@
-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

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

@@ -1,24 +0,0 @@
-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)

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

@@ -1,16 +0,0 @@
-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