throttle_machines 0.1.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff1906a9e597bee94979f637bf351aa53160ec2b349005ed731069bdb85cd032
-  data.tar.gz: 2293e5d59855593686cc2a8df0df560c5286452bc63bbcea4e13fca04d824c92
+  metadata.gz: 6450b4499ed28a6520bdc5d51a2c5bc7fcc55ba8e1f1e327def0ca9ab5c80d62
+  data.tar.gz: af1addd1f524c9f5663f3f241ce15bfb1aa9a6b5365463f3c9d453a9e03f0b05
 SHA512:
-  metadata.gz: 7c1fa93375186f6036c1efcba1292207ba0c831ee0d5e5bb73b7c985e2d45b3c52362d79d590ad1904a25568040e00e5929373381fb48da57155a646e8588e24
-  data.tar.gz: ae5ffa6881f0e7913227de2991ae8ffd17af31525040e43741491691cddde6ee8e4d27a9a2ad5dd5d2537335237e008f3397e9c4d3f45fab123cdac850ee7c73
+  metadata.gz: 564076859ef7219e48060400a26295cffc830a74fbf82d757766753e19d2020fce390ce8b91b9daf996147689dd47fec0911037a34a0208cd160ec3d6009ac70
+  data.tar.gz: 39590d460f59b66a700487146ea3309aa8df4d9f3b31e0248acb1b0748bc04b3a26f9a55f52f18b4beb3fca7618a8142092b4d434f45a4ce833a265d8e2c5fdb

data/README.md

@@ -33,6 +33,9 @@ gem 'redis'
 
 # For planetary Rails integration
 gem 'rails' # or just railties
+
+# For fiber-safe async throttling
+gem 'async'
 ```
 
 Then initialize systems:

data/lib/throttle_machines/async_breaker.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ThrottleMachines
+  class AsyncBreaker
+    class << self
+      def new(...)
+        ThrottleMachines.load_async_runtime!
+        BreakerMachines::AsyncCircuit.new(...)
+      end
+    end
+  end
+end

data/lib/throttle_machines/async_limiter.rb

@@ -1,16 +1,10 @@
 # frozen_string_literal: true
 
-require 'concurrent-ruby'
-
 module ThrottleMachines
-  # Async-aware rate limiter for fiber-safe operations
-  #
-  # Like quantum entanglement communications - allows multiple spacecraft
-  # to communicate simultaneously without interference, each in their own
-  # quantum state (fiber).
+  # Backward-compatible async-aware limiter class.
   #
   # Example:
-  #   limiter = ThrottleMachines::AsyncLimiter.new("quantum_comms",
+  #   limiter = ThrottleMachines::AsyncLimiter.new("api",
   #     limit: 100,
   #     period: 60,
   #     algorithm: :gcra
@@ -18,117 +12,13 @@ module ThrottleMachines
   #
   #   Async do
   #     if limiter.allowed_async?
-  #       # Non-blocking operation
+  #       # Currently allowed without consuming capacity
+  #     end
+  #
+  #     limiter.throttle_async(max_wait: 5) do
+  #       # Consumes capacity through the same atomic path as throttle!
   #     end
   #   end
   class AsyncLimiter < Limiter
-    def initialize(key, limit:, period:, algorithm: :fixed_window, storage: nil)
-      super
-      @fiber_storage = Concurrent::Map.new # Thread-safe fiber storage
-    end
-
-    # Async version of allowed? that's fiber-safe
-    def allowed_async?
-      allowed = if defined?(Async::Task) && Async::Task.current?
-                  # In async context, use fiber-local checking
-                  fiber_allowed?
-                else
-                  # Fall back to regular synchronous check
-                  allowed?
-                end
-
-      # Don't double-instrument when calling parent allowed?
-      return allowed unless defined?(Async::Task) && Async::Task.current?
-
-      # Instrument the async check
-      Instrumentation.rate_limit_checked(self, allowed: allowed, remaining: nil)
-      allowed
-    end
-
-    # Non-blocking check with async support
-    def check_async
-      if allowed_async?
-        yield if block_given?
-        true
-      else
-        false
-      end
-    end
-
-    # Async throttle with automatic retry
-    def throttle_async(max_wait: nil)
-      start_time = current_time
-
-      loop do
-        if allowed_async?
-          return yield if block_given?
-
-          return true
-        end
-
-        wait_time = retry_after
-
-        # Check if we've exceeded max wait time
-        if max_wait && (current_time - start_time + wait_time) > max_wait
-          raise ThrottleError, 'Maximum wait time exceeded'
-        end
-
-        # Non-blocking sleep in async context
-        if defined?(Async::Task) && Async::Task.current?
-          Async::Task.current.sleep(wait_time)
-        else
-          sleep(wait_time)
-        end
-      end
-    end
-
-    # Get current fiber's state
-    def fiber_state
-      fiber_id = Fiber.current.object_id
-      @fiber_storage.compute_if_absent(fiber_id) do
-        {
-          last_check: 0,
-          tokens: @limit.to_f
-        }
-      end
-    end
-
-    # Clean up fiber storage periodically
-    def cleanup_fiber_storage
-      current_fibers = ObjectSpace.each_object(Fiber).map(&:object_id)
-      @fiber_storage.each_key do |fiber_id|
-        @fiber_storage.delete(fiber_id) unless current_fibers.include?(fiber_id)
-      end
-    end
-
-    private
-
-    def fiber_allowed?
-      state = fiber_state
-      now = current_time
-
-      case @algorithm
-      when :token_bucket
-        # Refill tokens based on time passed
-        time_passed = now - state[:last_check]
-        tokens_to_add = time_passed * (@limit.to_f / @period)
-        state[:tokens] = [state[:tokens] + tokens_to_add, @limit.to_f].min
-        state[:last_check] = now
-
-        if state[:tokens] >= 1
-          state[:tokens] -= 1
-          true
-        else
-          false
-        end
-      else
-        # Delegate to parent for other algorithms
-        allowed?
-      end
-    end
-
-    def current_time
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
   end
 end

data/lib/throttle_machines/async_support.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Async/Fiber support for ThrottleMachines.
+#
+# The async gem is optional. When an Async task is active, waits yield back to
+# the scheduler; otherwise the limiter falls back to normal sleep.
+
+module ThrottleMachines
+  # Fiber-aware rate limiter helpers.
+  module AsyncSupport
+    def allowed_async?
+      allow?
+    end
+
+    alias allow_async? allowed_async?
+
+    def check_async
+      return false unless allowed_async?
+
+      yield if block_given?
+      true
+    end
+
+    def throttle_async(max_wait: nil, &block)
+      deadline = max_wait.nil? ? nil : ThrottleMachines.monotonic_time + max_wait.to_f
+
+      loop do
+        begin
+          throttle!
+        rescue ThrottledError => e
+          wait_time = [e.retry_after.to_f, 0.0].max
+
+          if deadline
+            remaining_wait = deadline - ThrottleMachines.monotonic_time
+            raise if remaining_wait <= 0 || wait_time > remaining_wait
+          end
+
+          sleep_for(wait_time)
+          next
+        end
+
+        return block.call if block
+
+        return true
+      end
+    end
+
+    private
+
+    # Use Async's fiber-aware sleep when in an async context.
+    def sleep_for(duration)
+      if (task = current_async_task)
+        task.sleep(duration)
+      else
+        sleep(duration)
+      end
+    end
+
+    def current_async_task
+      return nil unless defined?(::Async::Task)
+
+      if ::Async::Task.respond_to?(:current?)
+        ::Async::Task.current?
+      else
+        ::Async::Task.current
+      end
+    rescue StandardError
+      nil
+    end
+  end
+end
+
+ThrottleMachines::Limiter.include(ThrottleMachines::AsyncSupport)
+
+warn "[ThrottleMachines] Async support loaded" if ENV['DEBUG_MATRYOSHKA']

data/lib/throttle_machines/native_speedup.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Native speedup for ThrottleMachines using Rust FFI.
+#
+# This module is automatically loaded when the native extension is available.
+# It prepends optimized implementations onto Storage::Memory.
+#
+# Environment controls:
+#   DISABLE_MATRYOSHKA_NATIVE=1       - Disable all matryoshka native extensions
+#   DISABLE_THROTTLE_MACHINES_NATIVE=1 - Disable only throttle_machines native
+#   DEBUG_MATRYOSHKA=1                 - Log which backend is loaded
+
+return if ENV["DISABLE_MATRYOSHKA_NATIVE"]
+return if ENV["DISABLE_THROTTLE_MACHINES_NATIVE"]
+
+begin
+  require "throttle_machines_native/throttle_machines_native"
+
+  module ThrottleMachines
+    module Storage
+      # Native GCRA implementation using Rust.
+      module NativeGCRA
+        def check_gcra_limit(key, emission_interval, delay_tolerance, ttl)
+          with_write_lock(key) do
+            now = current_time
+            state = @gcra_states[key] || { tat: 0.0 }
+
+            # Rust does the math
+            ThrottleMachinesNative.gcra_check(
+              state[:tat], now, emission_interval, delay_tolerance
+            ) => { allowed:, state: new_tat, retry_after: }
+
+            @gcra_states[key] = { tat: new_tat, expires_at: now + ttl } if allowed
+
+            { allowed: allowed, retry_after: retry_after, tat: new_tat }
+          end
+        end
+
+        def peek_gcra_limit(key, _emission_interval, delay_tolerance)
+          with_read_lock(key) do
+            now = current_time
+            state = @gcra_states[key] || { tat: 0.0 }
+
+            # Rust does the math
+            ThrottleMachinesNative.gcra_peek(
+              state[:tat], now, delay_tolerance
+            ) => { allowed:, state: tat, retry_after: }
+
+            { allowed: allowed, retry_after: retry_after, tat: tat }
+          end
+        end
+      end
+
+      # Native Token Bucket implementation using Rust.
+      module NativeTokenBucket
+        def check_token_bucket(key, capacity, refill_rate, ttl)
+          with_write_lock(key) do
+            now = current_time
+            bucket = @token_buckets[key] || { tokens: capacity, last_refill: now }
+
+            # Rust does the math
+            ThrottleMachinesNative.token_bucket_check(
+              bucket[:tokens], bucket[:last_refill], now, capacity, refill_rate
+            ) => { allowed:, state: new_tokens, retry_after: }
+
+            if allowed
+              @token_buckets[key] = { tokens: new_tokens, last_refill: now, expires_at: now + ttl }
+            end
+
+            { allowed: allowed, retry_after: retry_after, tokens_remaining: new_tokens.floor }
+          end
+        end
+
+        def peek_token_bucket(key, capacity, refill_rate)
+          with_read_lock(key) do
+            now = current_time
+            bucket = @token_buckets[key] || { tokens: capacity, last_refill: now }
+
+            # Rust does the math
+            ThrottleMachinesNative.token_bucket_peek(
+              bucket[:tokens], bucket[:last_refill], now, capacity, refill_rate
+            ) => { allowed:, state: tokens, retry_after: }
+
+            { allowed: allowed, retry_after: retry_after, tokens_remaining: tokens.floor }
+          end
+        end
+      end
+    end
+  end
+
+  # Prepend native implementations
+  ThrottleMachines::Storage::Memory.prepend(ThrottleMachines::Storage::NativeGCRA)
+  ThrottleMachines::Storage::Memory.prepend(ThrottleMachines::Storage::NativeTokenBucket)
+
+  warn "[ThrottleMachines] Native speedup loaded" if ENV["DEBUG_MATRYOSHKA"]
+rescue LoadError => e
+  warn "[ThrottleMachines] Native speedup unavailable: #{e.message}" if ENV["DEBUG_MATRYOSHKA"]
+end

data/lib/throttle_machines/rack_middleware/allow2_ban.rb

@@ -2,18 +2,7 @@
 
 module ThrottleMachines
   class RackMiddleware
-    class Allow2Ban
-      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 Allow2Ban < BanFilter
       def matched_by?(request)
         discriminator = discriminator_for(request)
         return false unless discriminator
@@ -57,12 +46,6 @@ module ThrottleMachines
 
         false # Allow2Ban never blocks directly
       end
-
-      private
-
-      def discriminator_for(request)
-        @block.call(request)
-      end
     end
   end
 end

data/lib/throttle_machines/rack_middleware/ban_filter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ThrottleMachines
+  class RackMiddleware
+    # Base class for Fail2Ban and Allow2Ban filters.
+    #
+    # Both are configured with the same maxretry/findtime/bantime thresholds and
+    # derive a discriminator from the request via the supplied block. The ban
+    # logic itself lives in each subclass.
+    class BanFilter
+      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
+
+      private
+
+      def discriminator_for(request)
+        @block.call(request)
+      end
+    end
+  end
+end

data/lib/throttle_machines/rack_middleware/blocklist.rb

@@ -2,25 +2,12 @@
 
 module ThrottleMachines
   class RackMiddleware
-    class Blocklist
-      attr_reader :name, :block
+    # Blocks requests matching the configured block (returns true => blocked).
+    class Blocklist < 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'] = :blocklist
-          ThrottleMachines::RackMiddleware.instrument(request)
-          true
-        else
-          false
-        end
+      def match_type
+        :blocklist
       end
     end
   end

data/lib/throttle_machines/rack_middleware/fail2_ban.rb

@@ -2,18 +2,7 @@
 
 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
@@ -84,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

@@ -35,11 +35,9 @@ module ThrottleMachines
         @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/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/version.rb

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

data/lib/throttle_machines.rb

@@ -17,17 +17,32 @@ loader.setup
 module ThrottleMachines
   class Configuration
     attr_accessor :default_limit, :default_period, :default_storage, :clock,
-                  :instrumentation_enabled, :instrumentation_backend, :_storage_instance
+                  :default_algorithm, :instrumentation_enabled, :instrumentation_backend,
+                  :_storage_instance
 
     def initialize
       @default_limit = 100
       @default_period = 60 # 1 minute
       @default_storage = :memory
+      @default_algorithm = :fixed_window
       @clock = nil
       @instrumentation_enabled = true
       @instrumentation_backend = nil
+      @fiber_safe = false
       @_storage_instance = nil
     end
+
+    def fiber_safe
+      @fiber_safe
+    end
+
+    def fiber_safe=(value)
+      @fiber_safe = !!value
+      ThrottleMachines.load_async_runtime! if @fiber_safe && ThrottleMachines.respond_to?(:load_async_runtime!)
+    end
+
+    alias async_enabled fiber_safe
+    alias async_enabled= fiber_safe=
   end
 
   @config = Configuration.new
@@ -46,6 +61,7 @@ module ThrottleMachines
       # Apply instrumentation settings
       Instrumentation.enabled = config.instrumentation_enabled
       Instrumentation.backend = config.instrumentation_backend if config.instrumentation_backend
+      load_async_runtime! if config.fiber_safe
     end
 
     def storage
@@ -75,7 +91,7 @@ module ThrottleMachines
       control
     end
 
-    def limit(key, limit:, period:, algorithm: :fixed_window, &block)
+    def limit(key, limit:, period:, algorithm: nil, &block)
       limiter = limiter(key, limit: limit, period: period, algorithm: algorithm)
       limiter.throttle!(&block)
     end
@@ -99,8 +115,28 @@ module ThrottleMachines
       ChronoMachines.retry(policy_options, &block)
     end
 
-    def limiter(key, limit:, period:, algorithm: :fixed_window)
-      Limiter.new(key, limit: limit, period: period, algorithm: algorithm, storage: storage)
+    def limiter(key, limit:, period:, algorithm: nil)
+      Limiter.new(
+        key,
+        limit: limit,
+        period: period,
+        algorithm: algorithm || config.default_algorithm,
+        storage: storage
+      )
+    end
+
+    def async_breaker(...)
+      ThrottleMachines::AsyncBreaker.new(...)
+    end
+
+    def load_async_runtime!
+      require 'async'
+      require 'async/task'
+      true
+    rescue LoadError => e
+      raise unless e.message.include?('async')
+
+      raise LoadError, "The 'async' gem is required for fiber_safe mode. Add `gem 'async'` to your Gemfile."
     end
 
     private
@@ -145,3 +181,20 @@ module ThrottleMachines
   # Back-compat wrapper: use BreakerMachines as the circuit implementation
   Breaker = BreakerMachines::Circuit
 end
+
+# Optional speedups (order matters: most specific first)
+# These are loaded after Zeitwerk setup to allow graceful fallback.
+
+# Native Rust extension for performance-critical algorithms
+begin
+  require_relative "throttle_machines/native_speedup"
+rescue LoadError
+  # Native extension not available, pure Ruby will be used
+end
+
+# Async/Fiber support when Async gem is loaded
+begin
+  require_relative "throttle_machines/async_support"
+rescue LoadError
+  # Async gem not available
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: throttle_machines
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -71,28 +71,84 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '0.19'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '0.19'
 - !ruby/object:Gem::Dependency
   name: chrono_machines
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: ThrottleMachines provides ultra-thin, elegant rate limiting with temporal
   precision for distributed systems.
 email:
@@ -103,9 +159,10 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- Rakefile
 - lib/throttle_machines.rb
+- lib/throttle_machines/async_breaker.rb
 - lib/throttle_machines/async_limiter.rb
+- lib/throttle_machines/async_support.rb
 - lib/throttle_machines/control.rb
 - lib/throttle_machines/controller_helpers.rb
 - lib/throttle_machines/dependency_error.rb
@@ -115,11 +172,14 @@ files:
 - lib/throttle_machines/instrumentation.rb
 - lib/throttle_machines/limiter.rb
 - lib/throttle_machines/middleware.rb
+- lib/throttle_machines/native_speedup.rb
 - lib/throttle_machines/rack_middleware.rb
 - lib/throttle_machines/rack_middleware/allow2_ban.rb
+- lib/throttle_machines/rack_middleware/ban_filter.rb
 - lib/throttle_machines/rack_middleware/blocklist.rb
 - lib/throttle_machines/rack_middleware/configuration.rb
 - lib/throttle_machines/rack_middleware/fail2_ban.rb
+- lib/throttle_machines/rack_middleware/list_filter.rb
 - lib/throttle_machines/rack_middleware/request.rb
 - lib/throttle_machines/rack_middleware/safelist.rb
 - lib/throttle_machines/rack_middleware/throttle.rb
@@ -143,6 +203,8 @@ metadata:
   source_code_uri: https://github.com/seuros/throttle_machines
   changelog_uri: https://github.com/seuros/throttle_machines/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
+  cargo_crate_name: throttle_machines_native
+  cargo_manifest_path: ext/throttle_machines_native/ffi/Cargo.toml
 rdoc_options: []
 require_paths:
 - lib
@@ -150,14 +212,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.3.0
+      version: 4.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Advanced Rate limiting for Ruby applications
 test_files: []

data/Rakefile

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/**/*_test.rb'].exclude('test/dummy/**/*')
-  t.verbose = false
-end
-
-task default: :test