throttle_machines 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21546f9777cfd269ba2461dd3a3200173591defc6f20effb84fa8b7fb254353c
-  data.tar.gz: 4f82a87423e163ba277c5707b65dc122b1f0ba047ed97c29b5a877c14af92d94
+  metadata.gz: 1c498f9f097c1eac7384d573ea5e90b04e3850d6b236aae5a0f5b9bb0cdf29ae
+  data.tar.gz: 515fae0aad7083290b12cec368148e021ff9312fb026892fb4574fd89a1a0f6c
 SHA512:
-  metadata.gz: 61d639a39194c9d504871e2159a30ab89671d3f42f333d1f283ecc7a7fb1c238d948a5dfa3c336a6c05fec5e3065613d00610027fbdcf6af0d3df5277dc02a2a
-  data.tar.gz: b844e1d3ce3949c273e996972770f7d5f1aa1d3a5729da02d54651915bd826b327dd2826e96d4c09ac6ac921e720b437494ed3eac4d2c7b8db776e6f50244d3a
+  metadata.gz: ec8ac810c8696a93a44bcf305245eef336ce338418b82a5236e73fa919afda7125cee2ac391c0230419f136525ee1104723dc3a81e42517c4c0a48ebd6878d76
+  data.tar.gz: 3908d0866286abc0556b79160c8543da2b542ab3cfb55b2c2d636fc69bb0393196848f920714e89e4926d7e4450ae5de33329d0774ae4a0f8f59860bbbaad620

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

data/lib/throttle_machines/engine.rb

@@ -15,10 +15,8 @@ module ThrottleMachines
 
     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
+        # Use Rails.cache , user can override
+        config.store = Rails.cache
       end
     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(&)
+      @hedged.run do |attempt|
+        breaker = @breakers[attempt]
+        next if breaker.nil?
+
+        breaker.call(&)
+      end
+    end
+  end
+end

data/lib/throttle_machines/hedged_request.rb

@@ -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,11 +12,7 @@ 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 = {}, &)

data/lib/throttle_machines/rack_middleware.rb

@@ -35,9 +35,11 @@ module ThrottleMachines
         @configuration.instance_eval(&) 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/memory.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base'
 require 'concurrent'
 
 module ThrottleMachines

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

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/get_breaker_state.lua

@@ -0,0 +1,23 @@
+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/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/record_breaker_failure.lua

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

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

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,19 @@
 # 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
-
-        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
+      # Load Lua scripts from files
+      LUA_SCRIPTS_DIR = File.expand_path('redis', __dir__)
+
+      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'))
+      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'))
 
       def initialize(options = {})
         super
@@ -117,17 +36,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
 
@@ -262,31 +171,7 @@ module ThrottleMachines
 
         # 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
+          redis.eval(GET_BREAKER_STATE_SCRIPT, keys: [breaker_key], argv: [current_time])
         end
 
         return { state: :closed, failures: 0, last_failure: nil } if result.empty?
@@ -309,24 +194,7 @@ module ThrottleMachines
 
         # 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
+          redis.eval(RECORD_BREAKER_SUCCESS_SCRIPT, keys: [breaker_key], argv: [half_open_requests])
         end
       end
 
@@ -336,32 +204,7 @@ module ThrottleMachines
 
         # 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
+          redis.eval(RECORD_BREAKER_FAILURE_SCRIPT, keys: [breaker_key], argv: [threshold, timeout, now])
         end
 
         get_breaker_state(key)

data/lib/throttle_machines/version.rb

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

data/lib/throttle_machines.rb

@@ -14,9 +14,6 @@ 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
 
@@ -132,7 +129,6 @@ 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
 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.1
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -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,14 @@ 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/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
 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