sidekiq-queue-throttled 1.0.0 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f04395444525e11488352d423c291bbefa3d15cd0415cea21a6a248fe9ec11f1
-  data.tar.gz: 97e5ee1c7501c66e598fa6638a30a2cb1ba39801dbef610456aa590e2300685c
+  metadata.gz: b658041cc8f4b7cb1cd5055c8371e3c672c4f74f9151faf5a67dda68f014d6ac
+  data.tar.gz: 36afa33c4f2250d70bf55c52318fbedbe2a10e6a629c557d676b81bd1fadf485
 SHA512:
-  metadata.gz: c8e536136b78764fe9fa29ac5666839fdac9c81f53d6edf23a0725abb9459966f6a5e0b35c3b47099d665a569e28fc222a6bbc5e49f4b4597c8bce0cd7d51db8
-  data.tar.gz: 8dfae89423e246c267efa76eda12237e10885917cb519aea643f6e2868d100dd1db518a6f9d5fe5b27bcb01f41c9bb9b4ca80277ae289a97426a4e6e6556ad28
+  metadata.gz: 2f6c4dc62bbd48be8646598d3e8aca5cb3baa2572bd80082c121fe140a7e13369694ef5420ecafd169fceb46344efec250d02a6398b8b7ac955b952faf33b710
+  data.tar.gz: deb6e902be8ea36f1b63a7bf630bcd8c28800360713349fa18a8f4ab07be142638d8437fb8e6e5ec5b7c0501aaab14be23f0a19b06b692fc53d87ba5e6fa995c

data/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.3] - 2024-12-19
+
+### Changed
+- Re-enabled MFA requirement for RubyGems deployment for enhanced security
+
+## [1.1.2] - 2024-12-19
+
+### Changed
+- Disabled MFA requirement for RubyGems deployment to simplify release process
+
 ## [Unreleased]
 
 ### Added

data/README.md

@@ -25,6 +25,18 @@ And then execute:
 $ bundle install
 ```
 
+### Rails Applications
+
+For Rails applications, the gem will be automatically loaded when your application starts. No additional configuration is required.
+
+### Non-Rails Applications
+
+For non-Rails applications, you need to explicitly require the gem:
+
+```ruby
+require 'sidekiq/queue_throttled'
+```
+
 ## Configuration
 
 ### Queue Limits
@@ -203,7 +215,7 @@ Sidekiq::QueueThrottled.redis = Redis.new(url: ENV['REDIS_URL'])
 limiter = Sidekiq::QueueThrottled::QueueLimiter.new(queue_name, limit)
 
 # Acquire a lock (returns lock_id or false)
-lock_id = limiter.acquire_lock
+lock_id = limiter.acquire_lock?
 
 # Release a lock
 limiter.release_lock(lock_id)
@@ -272,9 +284,9 @@ RSpec.describe "Queue Limiting" do
   it "respects queue limits" do
     limiter = Sidekiq::QueueThrottled::QueueLimiter.new("test_queue", 2)
     
-    expect(limiter.acquire_lock).to be_truthy
-    expect(limiter.acquire_lock).to be_truthy
-    expect(limiter.acquire_lock).to be_falsey # Limit reached
+    expect(limiter.acquire_lock?).to be_truthy
+    expect(limiter.acquire_lock?).to be_truthy
+    expect(limiter.acquire_lock?).to be_falsey # Limit reached
   end
 end
 ```
@@ -286,6 +298,30 @@ end
 - **Network Latency**: Consider Redis network latency when setting TTL values
 - **Concurrent Access**: The gem uses thread-safe primitives for concurrent access
 
+## Troubleshooting
+
+### "uninitialized constant Sidekiq::QueueThrottled" Error
+
+If you encounter this error when trying to use the gem:
+
+```
+uninitialized constant Sidekiq::QueueThrottled (NameError)
+```
+
+**For Rails applications:**
+- Make sure the gem is properly added to your Gemfile
+- Restart your Rails server after adding the gem
+- The gem should auto-load when your Rails application starts
+
+**For non-Rails applications:**
+- Explicitly require the gem at the top of your file:
+  ```ruby
+  require 'sidekiq/queue_throttled'
+  ```
+
+**For IRB/Console:**
+- If you're testing in IRB or Rails console, make sure to restart the console after adding the gem to your Gemfile
+
 ## Contributing
 
 1. Fork the repository

data/lib/sidekiq/queue_throttled/job.rb

@@ -5,12 +5,24 @@ module Sidekiq
     module Job
       def self.included(base)
         base.extend(ClassMethods)
+        setup_class_attributes(base)
+      end
+
+      def self.setup_class_attributes(base)
+        setup_attr_accessor(base)
+        setup_class_methods(base)
+      end
+
+      def self.setup_attr_accessor(base)
         base.class_eval do
-          # Simple class attribute implementation
           class << self
             attr_accessor :sidekiq_throttle_config
           end
+        end
+      end
 
+      def self.setup_class_methods(base)
+        base.class_eval do
           def self.sidekiq_throttle_config
             @sidekiq_throttle_config
           end
@@ -31,50 +43,39 @@ module Sidekiq
 
         def validate_throttle_options!(options)
           return if options.empty?
+          raise ArgumentError, 'Cannot specify both concurrency and rate limits' if both_limits?(options)
 
-          if options[:concurrency] && options[:rate]
-            raise ArgumentError, 'Cannot specify both concurrency and rate limits'
-          end
-
-          if options[:concurrency]
-            validate_concurrency_options!(options[:concurrency])
-          end
+          validate_concurrency_options!(options[:concurrency]) if options[:concurrency]
+          validate_rate_options!(options[:rate]) if options[:rate]
+        end
 
-          if options[:rate]
-            validate_rate_options!(options[:rate])
-          end
+        def both_limits?(options)
+          options[:concurrency] && options[:rate]
         end
 
         def validate_concurrency_options!(concurrency)
-          unless concurrency.is_a?(Hash)
-            raise ArgumentError, 'Concurrency must be a hash'
-          end
+          raise ArgumentError, 'Concurrency must be a hash' unless concurrency.is_a?(Hash)
 
           unless concurrency[:limit].is_a?(Integer) && concurrency[:limit].positive?
-            raise ArgumentError, 'Concurrency limit must be a positive integer'
-          end
-
-          unless concurrency[:key_suffix]
-            raise ArgumentError, 'Concurrency key_suffix is required'
+            raise ArgumentError,
+                  'Concurrency limit must be a positive integer'
           end
+          raise ArgumentError, 'Concurrency key_suffix is required' unless concurrency[:key_suffix]
         end
 
         def validate_rate_options!(rate)
-          unless rate.is_a?(Hash)
-            raise ArgumentError, 'Rate must be a hash'
-          end
-
-          unless rate[:limit].is_a?(Integer) && rate[:limit].positive?
-            raise ArgumentError, 'Rate limit must be a positive integer'
-          end
+          raise ArgumentError, 'Rate must be a hash' unless rate.is_a?(Hash)
+          raise ArgumentError, 'Rate limit must be a positive integer' unless valid_rate_limit?(rate)
+          raise ArgumentError, 'Rate period must be a positive integer' unless valid_rate_period?(rate)
+          raise ArgumentError, 'Rate key_suffix is required' unless rate[:key_suffix]
+        end
 
-          unless rate[:period].nil? || (rate[:period].is_a?(Integer) && rate[:period].positive?)
-            raise ArgumentError, 'Rate period must be a positive integer'
-          end
+        def valid_rate_limit?(rate)
+          rate[:limit].is_a?(Integer) && rate[:limit].positive?
+        end
 
-          unless rate[:key_suffix]
-            raise ArgumentError, 'Rate key_suffix is required'
-          end
+        def valid_rate_period?(rate)
+          rate[:period].nil? || (rate[:period].is_a?(Integer) && rate[:period].positive?)
         end
       end
     end

data/lib/sidekiq/queue_throttled/job_throttler.rb

@@ -2,7 +2,33 @@
 
 module Sidekiq
   module QueueThrottled
+    module RedisKeyManager
+      def concurrency_key(key_suffix)
+        "#{Sidekiq::QueueThrottled.configuration.redis_key_prefix}:concurrency:#{@job_class}:#{key_suffix}"
+      end
+
+      def rate_key(key_suffix, period)
+        window = Time.now.to_i / period
+        "#{Sidekiq::QueueThrottled.configuration.redis_key_prefix}:rate:#{@job_class}:#{key_suffix}:#{window}"
+      end
+
+      def resolve_key_suffix(key_suffix, args)
+        case key_suffix
+        when Proc
+          key_suffix.call(*args)
+        when Symbol
+          args.first.send(key_suffix) if args.first.respond_to?(key_suffix)
+        when String
+          key_suffix
+        else
+          'default'
+        end.to_s
+      end
+    end
+
     class JobThrottler
+      include RedisKeyManager
+
       attr_reader :job_class, :throttle_config, :redis
 
       def initialize(job_class, throttle_config, redis = nil)
@@ -15,9 +41,7 @@ module Sidekiq
       def can_process?(args)
         return true unless @throttle_config
 
-        @mutex.with_read_lock do
-          check_concurrency_limit(args) && check_rate_limit(args)
-        end
+        @mutex.with_read_lock { concurrency_allowed?(args) && rate_allowed?(args) }
       end
 
       def acquire_slot(args)
@@ -25,14 +49,10 @@ module Sidekiq
 
         @mutex.with_write_lock do
           return false unless can_process?(args)
+          return acquire_concurrency_slot?(args) if @throttle_config[:concurrency]
+          return acquire_rate_slot?(args) if @throttle_config[:rate]
 
-          if @throttle_config[:concurrency]
-            acquire_concurrency_slot(args)
-          elsif @throttle_config[:rate]
-            acquire_rate_slot(args)
-          else
-            true
-          end
+          true
         end
       end
 
@@ -40,12 +60,8 @@ module Sidekiq
         return true unless @throttle_config
 
         @mutex.with_write_lock do
-          if @throttle_config[:concurrency]
-            release_concurrency_slot(args)
-          end
-          # Rate limiting slots are not released - they expire naturally
+          release_concurrency_slot?(args) if @throttle_config[:concurrency]
         end
-
         true
       rescue StandardError => e
         Sidekiq::QueueThrottled.logger.error "Failed to release slot for job #{@job_class}: #{e.message}"
@@ -54,102 +70,72 @@ module Sidekiq
 
       private
 
-      def check_concurrency_limit(args)
+      def concurrency_allowed?(args)
         return true unless @throttle_config[:concurrency]
 
         config = @throttle_config[:concurrency]
         limit = config[:limit]
         key_suffix = resolve_key_suffix(config[:key_suffix], args)
-        current_count = get_concurrency_count(key_suffix)
-
+        current_count = concurrency_count(key_suffix)
         current_count < limit
       end
 
-      def check_rate_limit(args)
+      def rate_allowed?(args)
         return true unless @throttle_config[:rate]
 
         config = @throttle_config[:rate]
         limit = config[:limit]
         period = config[:period] || 60
         key_suffix = resolve_key_suffix(config[:key_suffix], args)
-
-        current_count = get_rate_count(key_suffix, period)
+        current_count = rate_count(key_suffix, period)
         current_count < limit
       end
 
-      def acquire_concurrency_slot(args)
+      def acquire_concurrency_slot?(args)
         config = @throttle_config[:concurrency]
         key_suffix = resolve_key_suffix(config[:key_suffix], args)
         key = concurrency_key(key_suffix)
-
         @redis.multi do |multi|
           multi.incr(key)
           multi.expire(key, Sidekiq::QueueThrottled.configuration.throttle_ttl)
         end
-
         true
       end
 
-      def release_concurrency_slot(args)
+      def release_concurrency_slot?(args)
         config = @throttle_config[:concurrency]
         key_suffix = resolve_key_suffix(config[:key_suffix], args)
         key = concurrency_key(key_suffix)
-
         @redis.multi do |multi|
           multi.decr(key)
           multi.expire(key, Sidekiq::QueueThrottled.configuration.throttle_ttl)
         end
-
         true
       end
 
-      def acquire_rate_slot(args)
+      def acquire_rate_slot?(args)
         config = @throttle_config[:rate]
         period = config[:period] || 60
         key_suffix = resolve_key_suffix(config[:key_suffix], args)
         key = rate_key(key_suffix, period)
-
         @redis.multi do |multi|
           multi.incr(key)
           multi.expire(key, period)
         end
-
         true
       end
 
-      def get_concurrency_count(key_suffix)
+      def concurrency_count(key_suffix)
         key = concurrency_key(key_suffix)
         count = @redis.get(key)
         count ? count.to_i : 0
       end
 
-      def get_rate_count(key_suffix, period)
+      def rate_count(key_suffix, period)
         key = rate_key(key_suffix, period)
         count = @redis.get(key)
         count ? count.to_i : 0
       end
-
-      def concurrency_key(key_suffix)
-        "#{Sidekiq::QueueThrottled.configuration.redis_key_prefix}:concurrency:#{@job_class}:#{key_suffix}"
-      end
-
-      def rate_key(key_suffix, period)
-        window = Time.now.to_i / period
-        "#{Sidekiq::QueueThrottled.configuration.redis_key_prefix}:rate:#{@job_class}:#{key_suffix}:#{window}"
-      end
-
-      def resolve_key_suffix(key_suffix, args)
-        case key_suffix
-        when Proc
-          key_suffix.call(*args)
-        when Symbol
-          args.first.send(key_suffix) if args.first.respond_to?(key_suffix)
-        when String
-          key_suffix
-        else
-          'default'
-        end.to_s
-      end
     end
   end
 end

data/lib/sidekiq/queue_throttled/middleware.rb

@@ -8,84 +8,90 @@ module Sidekiq
         @job_throttlers = Concurrent::Map.new
       end
 
-      def call(worker, job, queue)
+      def call(worker, job, queue, &block)
         queue_name = job['queue'] || queue
         job_class = worker.class.name
 
-        # Check queue-level limits
+        return reschedule_and_return(job, queue_name, 'queue') unless queue_slot_available?(queue_name, job)
+        return reschedule_and_return(job, queue_name, 'job') unless job_slot_available?(job_class, job['args'], job)
+
+        process_job(job, queue_name, job_class, &block)
+      end
+
+      private
+
+      def queue_slot_available?(queue_name, job)
         queue_limiter = get_queue_limiter(queue_name)
-        if queue_limiter
-          lock_id = queue_limiter.acquire_lock
-          unless lock_id
-            Sidekiq::QueueThrottled.logger.info "Queue limit reached for #{queue_name}, rescheduling job"
-            reschedule_job(job, queue_name)
-            return nil
-          end
-        end
+        return true unless queue_limiter
 
-        # Check job-level throttling
+        lock_id = queue_limiter.acquire_lock?
+        job['lock_id'] = lock_id if lock_id
+        !!lock_id
+      end
+
+      def job_slot_available?(job_class, args, job)
         job_throttler = get_job_throttler(job_class)
-        if job_throttler && !job_throttler.acquire_slot(job['args'])
-          Sidekiq::QueueThrottled.logger.info "Job throttling limit reached for #{job_class}, rescheduling job"
-          reschedule_job(job, queue_name)
-          return nil
-        end
+        return true unless job_throttler
 
-        # Process the job
+        acquired = job_throttler.acquire_slot(args)
+        job['job_throttle_acquired'] = acquired
+        acquired
+      end
+
+      def process_job(job, queue_name, job_class, &_block)
+        queue_limiter = get_queue_limiter(queue_name)
+        job_throttler = get_job_throttler(job_class)
+        lock_id = job['lock_id']
         begin
           yield
         ensure
-          # Release locks
           queue_limiter&.release_lock(lock_id)
           job_throttler&.release_slot(job['args'])
         end
       end
 
-      private
+      def reschedule_and_return(job, queue_name, type)
+        msg = type == 'queue' ? 'Queue limit reached' : 'Job throttling limit reached'
+        Sidekiq::QueueThrottled.logger.info "#{msg} for #{queue_name}, rescheduling job"
+        reschedule_job(job, queue_name)
+        nil
+      end
 
       def get_queue_limiter(queue_name)
         limit = Sidekiq::QueueThrottled.configuration.queue_limit(queue_name)
         return nil unless limit
 
-        @queue_limiters.compute_if_absent(queue_name) do
-          QueueLimiter.new(queue_name, limit)
-        end
+        @queue_limiters.compute_if_absent(queue_name) { QueueLimiter.new(queue_name, limit) }
       end
 
       def get_job_throttler(job_class)
-        throttle_config = get_throttle_config(job_class)
+        throttle_config = throttle_config_for(job_class)
         return nil unless throttle_config
 
-        @job_throttlers.compute_if_absent(job_class) do
-          JobThrottler.new(job_class, throttle_config)
-        end
+        @job_throttlers.compute_if_absent(job_class) { JobThrottler.new(job_class, throttle_config) }
       end
 
-      def get_throttle_config(job_class)
-        # Handle string class names
+      def throttle_config_for(job_class)
         if job_class.is_a?(String)
-          begin
-            klass = Object.const_get(job_class)
-            return klass.sidekiq_throttle_config if klass.respond_to?(:sidekiq_throttle_config)
-          rescue NameError
-            # For test classes that don't have proper constant names
-            return nil
-          end
+          klass = safe_const_get(job_class)
+          return klass.sidekiq_throttle_config if klass.respond_to?(:sidekiq_throttle_config)
         elsif job_class.respond_to?(:sidekiq_throttle_config)
-          # Handle actual class objects
           return job_class.sidekiq_throttle_config
         end
         nil
       end
 
+      def safe_const_get(class_name)
+        Object.const_get(class_name)
+      rescue NameError
+        nil
+      end
+
       def reschedule_job(job, queue_name)
         delay = Sidekiq::QueueThrottled.configuration.retry_delay
         job['at'] = Time.now.to_f + delay
         job['queue'] = queue_name
-
-        Sidekiq.redis do |conn|
-          conn.zadd('schedule', job['at'], job.to_json)
-        end
+        Sidekiq.redis { |conn| conn.zadd('schedule', job['at'], job.to_json) }
       end
     end
   end

data/lib/sidekiq/queue_throttled/queue_limiter.rb

@@ -14,42 +14,28 @@ module Sidekiq
         @mutex = Concurrent::ReentrantReadWriteLock.new
       end
 
-      def acquire_lock(worker_id = nil)
+      def acquire_lock?(worker_id = nil)
         worker_id ||= SecureRandom.uuid
         lock_id = "#{worker_id}:#{Time.now.to_f}"
-
         @mutex.with_write_lock do
-          current_count = get_current_count
-          puts "DEBUG: QueueLimiter - current_count: #{current_count}, limit: #{@limit}"
-          return false if current_count >= @limit
+          return false if limit_reached?
 
-          # Increment the counter first
           increment_counter
-          puts "DEBUG: QueueLimiter - acquired lock: #{lock_id}"
-          return lock_id
+          lock_id
         end
-
-        false
       end
 
       def release_lock(lock_id)
         return false unless lock_id
 
-        @mutex.with_write_lock do
-          # For time-based limiting, we don't immediately decrement the counter
-          # The counter will expire naturally after the TTL period
-          # This prevents immediate reuse of slots
-          true
-        end
+        @mutex.with_write_lock { true }
       rescue StandardError => e
         Sidekiq::QueueThrottled.logger.error "Failed to release lock #{lock_id} for queue #{@queue_name}: #{e.message}"
         false
       end
 
       def current_count
-        @mutex.with_read_lock do
-          get_current_count
-        end
+        @mutex.with_read_lock { fetch_current_count }
       end
 
       def available_slots
@@ -59,7 +45,6 @@ module Sidekiq
       def reset!
         @mutex.with_write_lock do
           @redis.del(@counter_key)
-          # Clear all locks for this queue
           pattern = "#{Sidekiq::QueueThrottled.configuration.redis_key_prefix}:queue:#{@queue_name}:lock:*"
           keys = @redis.keys(pattern)
           @redis.del(*keys) unless keys.empty?
@@ -68,7 +53,11 @@ module Sidekiq
 
       private
 
-      def get_current_count
+      def limit_reached?
+        fetch_current_count >= @limit
+      end
+
+      def fetch_current_count
         count = @redis.get(@counter_key)
         result = count ? count.to_i : 0
         puts "DEBUG: get_current_count - key: #{@counter_key}, count: #{result}"
@@ -81,7 +70,7 @@ module Sidekiq
           multi.incr(@counter_key)
           multi.expire(@counter_key, Sidekiq::QueueThrottled.configuration.throttle_ttl)
         end
-        puts "DEBUG: increment_counter - after increment, count: #{get_current_count}"
+        puts "DEBUG: increment_counter - after increment, count: #{fetch_current_count}"
       end
 
       def decrement_counter
@@ -89,11 +78,8 @@ module Sidekiq
           multi.decr(@counter_key)
           multi.expire(@counter_key, Sidekiq::QueueThrottled.configuration.throttle_ttl)
         end
-        # Ensure counter doesn't go below 0
-        current = get_current_count
-        if current.negative?
-          @redis.set(@counter_key, 0)
-        end
+        current = fetch_current_count
+        @redis.set(@counter_key, 0) if current.negative?
       end
 
       def acquire_redis_lock(lock_id)
@@ -101,7 +87,7 @@ module Sidekiq
         @redis.set(lock_key, '1', nx: true, ex: Sidekiq::QueueThrottled.configuration.lock_ttl)
       end
 
-      def release_redis_lock(lock_id)
+      def release_redis_lock?(lock_id)
         lock_key = "#{@lock_key}:#{lock_id}"
         @redis.del(lock_key).positive?
       end

data/lib/sidekiq/queue_throttled/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+module Sidekiq
+  module QueueThrottled
+    class Railtie < Rails::Railtie
+      initializer 'sidekiq.queue_throttled' do
+        require 'sidekiq/queue_throttled'
+      end
+    end
+  end
+end

data/lib/sidekiq/queue_throttled/version.rb

@@ -2,6 +2,6 @@
 
 module Sidekiq
   module QueueThrottled
-    VERSION = '1.0.0'
+    VERSION = '1.1.4'
   end
 end

data/lib/sidekiq/queue_throttled.rb

@@ -13,6 +13,14 @@ require_relative 'queue_throttled/job_throttler'
 require_relative 'queue_throttled/middleware'
 require_relative 'queue_throttled/job'
 
+# Auto-load Rails integration if Rails is available
+begin
+  require 'rails'
+  require_relative 'queue_throttled/railtie'
+rescue LoadError
+  # Rails is not available, which is fine for non-Rails applications
+end
+
 module Sidekiq
   module QueueThrottled
     class << self

data/spec/examples.txt

@@ -1,110 +1,115 @@
 example_id                                                    | status | run_time        |
 ------------------------------------------------------------- | ------ | --------------- |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:1:1]   | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:1:2]   | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:1:3]   | passed | 0.00009 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:1:1]   | passed | 0.0019 seconds  |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:1:2]   | passed | 0.00016 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:1:3]   | passed | 0.00017 seconds |
 ./spec/sidekiq/queue_throttled/configuration_spec.rb[1:2:1]   | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:2:2]   | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:2:3]   | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:3:1]   | passed | 0.00019 seconds |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:3:2]   | passed | 0.0002 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:3:3]   | passed | 0.00354 seconds |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:4:1]   | passed | 0.00031 seconds |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:4:2]   | passed | 0.00437 seconds |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:4:3]   | passed | 0.01693 seconds |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:5:1]   | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:5:2]   | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:5:3]   | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:5:4]   | passed | 0.00011 seconds |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:6:1]   | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:6:2]   | passed | 0.00009 seconds |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:6:3]   | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/configuration_spec.rb[1:6:4]   | passed | 0.00009 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:1:1]             | passed | 0.00014 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:1:2]             | passed | 0.00013 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:1]             | passed | 0.00015 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:2]             | passed | 0.00019 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:3]             | passed | 0.00012 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:4]             | passed | 0.00015 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:5]             | passed | 0.00017 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:6]             | passed | 0.00015 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:7]             | passed | 0.00015 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:8]             | passed | 0.00016 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:9]             | passed | 0.00016 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:10]            | passed | 0.00016 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:11]            | passed | 0.00015 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:12]            | passed | 0.00016 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:2:13]            | passed | 0.00016 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:3:1]             | passed | 0.00072 seconds |
-./spec/sidekiq/queue_throttled/job_spec.rb[1:3:2]             | passed | 0.00139 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:1:1]   | passed | 0.00024 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:1:2]   | passed | 0.00018 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:1:1] | passed | 0.00011 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:2:1] | passed | 0.00022 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:2:2] | passed | 0.00065 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:2:3] | passed | 0.00053 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:3:1] | passed | 0.00015 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:3:2] | passed | 0.00047 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:3:3] | passed | 0.00072 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:4:1] | passed | 0.0003 seconds  |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:1:1] | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:2:1] | passed | 0.00037 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:2:2] | passed | 0.00066 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:2:3] | passed | 0.00079 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:3:1] | passed | 0.00022 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:3:2] | passed | 0.00043 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:4:1:1] | passed | 0.0045 seconds  |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:4:2:1] | passed | 0.00214 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:4:2:2] | passed | 0.00612 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:4:3:1] | passed | 0.00015 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:5:1:1] | passed | 0.00066 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:5:2:1] | passed | 0.00079 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:2:2]   | passed | 0.00017 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:2:3]   | passed | 0.00057 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:3:1]   | passed | 0.00016 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:3:2]   | passed | 0.0001 seconds  |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:3:3]   | passed | 0.00098 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:4:1]   | passed | 0.00046 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:4:2]   | passed | 0.00045 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:4:3]   | passed | 0.0121 seconds  |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:5:1]   | passed | 0.00082 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:5:2]   | passed | 0.00016 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:5:3]   | passed | 0.00021 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:5:4]   | passed | 0.00016 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:6:1]   | passed | 0.00014 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:6:2]   | passed | 0.00016 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:6:3]   | passed | 0.00013 seconds |
+./spec/sidekiq/queue_throttled/configuration_spec.rb[1:6:4]   | passed | 0.0001 seconds  |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:1:1]             | passed | 0.00056 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:1:2]             | passed | 0.0002 seconds  |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:1]             | passed | 0.00014 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:2]             | passed | 0.00013 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:3]             | passed | 0.00013 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:4]             | passed | 0.00019 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:5]             | passed | 0.00012 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:6]             | passed | 0.00012 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:7]             | passed | 0.00011 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:8]             | passed | 0.00014 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:9]             | passed | 0.00011 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:10]            | passed | 0.00013 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:11]            | passed | 0.00011 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:12]            | passed | 0.00013 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:2:13]            | passed | 0.00013 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:3:1]             | passed | 0.00073 seconds |
+./spec/sidekiq/queue_throttled/job_spec.rb[1:3:2]             | passed | 0.0015 seconds  |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:1:1]   | passed | 0.00014 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:1:2]   | passed | 0.00016 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:1:1] | passed | 0.00017 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:2:1] | passed | 0.00024 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:2:2] | passed | 0.0009 seconds  |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:2:3] | passed | 0.0007 seconds  |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:3:1] | passed | 0.00026 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:3:2] | passed | 0.00076 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:3:3] | passed | 0.00075 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:2:4:1] | passed | 0.00061 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:1:1] | passed | 0.00013 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:2:1] | passed | 0.00046 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:2:2] | passed | 0.00071 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:2:3] | passed | 0.00078 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:3:1] | passed | 0.00037 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:3:3:2] | passed | 0.00068 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:4:1:1] | passed | 0.00012 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:4:2:1] | passed | 0.0006 seconds  |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:4:2:2] | passed | 0.0051 seconds  |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:4:3:1] | passed | 0.00011 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:5:1:1] | passed | 0.0006 seconds  |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:5:2:1] | passed | 0.00056 seconds |
 ./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:5:2:2] | passed | 0.00024 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:5:3:1] | passed | 0.00054 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:5:4:1] | passed | 0.00068 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:6:1]   | passed | 0.00155 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:6:2]   | passed | 0.00058 seconds |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:6:3]   | passed | 0.0007 seconds  |
-./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:7:1]   | passed | 0.0013 seconds  |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:1:1]    | passed | 0.00033 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:2:1]    | passed | 0.00045 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:2:2]    | passed | 0.00296 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:3:1]    | passed | 0.00073 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:3:2]    | passed | 0.00098 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:3:3]    | passed | 0.00104 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:4:1]    | passed | 0.00105 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:5:1]    | passed | 0.00068 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:5:2]    | passed | 0.00223 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:2:1]      | passed | 0.00009 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:2:2]      | passed | 0.00013 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:2:3]      | passed | 0.0001 seconds  |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:3:1]      | passed | 0.00015 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:3:2]      | passed | 0.00058 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:3:3]      | passed | 0.00023 seconds |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:4:1]      | passed | 0.0005 seconds  |
-./spec/sidekiq/queue_throttled/middleware_spec.rb[1:4:2]      | passed | 0.00098 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:1:1]   | passed | 0.00013 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:1:2]   | passed | 0.00014 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:1:3]   | passed | 0.00016 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:2:1]   | passed | 0.0004 seconds  |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:2:2]   | passed | 0.0011 seconds  |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:2:3]   | passed | 0.00088 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:2:4]   | passed | 0.00046 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:2:5]   | passed | 0.00058 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:3:1]   | passed | 0.00058 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:3:2]   | passed | 0.00014 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:5:3:1] | passed | 0.00048 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:5:4:1] | passed | 0.00051 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:6:1]   | passed | 0.00092 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:6:2]   | passed | 0.00057 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:6:3]   | passed | 0.00045 seconds |
+./spec/sidekiq/queue_throttled/job_throttler_spec.rb[1:7:1]   | passed | 0.00121 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:1:1]    | passed | 0.00052 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:2:1]    | passed | 0.00054 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:2:2]    | passed | 0.0011 seconds  |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:3:1]    | passed | 0.00114 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:3:2]    | passed | 0.0028 seconds  |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:3:3]    | passed | 0.0016 seconds  |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:4:1]    | passed | 0.0012 seconds  |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:5:1]    | passed | 0.00116 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:1:5:2]    | passed | 0.00146 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:2:1]      | passed | 0.00013 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:2:2]      | passed | 0.00014 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:2:3]      | passed | 0.00013 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:3:1]      | passed | 0.00013 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:3:2]      | passed | 0.00018 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:3:3]      | passed | 0.00018 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:4:1]      | passed | 0.00052 seconds |
+./spec/sidekiq/queue_throttled/middleware_spec.rb[1:4:2]      | passed | 0.00094 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:1:1]   | passed | 0.00012 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:1:2]   | passed | 0.0001 seconds  |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:1:3]   | passed | 0.0002 seconds  |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:2:1]   | passed | 0.00067 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:2:2]   | passed | 0.001 seconds   |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:2:3]   | passed | 0.0013 seconds  |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:2:4]   | passed | 0.00281 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:2:5]   | passed | 0.00075 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:3:1]   | passed | 0.00038 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:3:2]   | passed | 0.00011 seconds |
 ./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:3:3]   | passed | 0.00016 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:3:4]   | passed | 0.00038 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:4:1]   | passed | 0.0002 seconds  |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:4:2]   | passed | 0.00098 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:4:3]   | passed | 0.00095 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:5:1]   | passed | 0.00021 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:5:2]   | passed | 0.00045 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:5:3]   | passed | 0.00112 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:5:4]   | passed | 0.00023 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:6:1]   | passed | 0.00081 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:6:2]   | passed | 0.00152 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:7:1]   | passed | 0.00151 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:7:2]   | passed | 0.00136 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:8:1]   | passed | 0.00066 seconds |
-./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:8:2]   | passed | 0.00093 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:3:4]   | passed | 0.00041 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:4:1]   | passed | 0.00016 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:4:2]   | passed | 0.00058 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:4:3]   | passed | 0.00063 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:5:1]   | passed | 0.00023 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:5:2]   | passed | 0.00067 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:5:3]   | passed | 0.0013 seconds  |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:5:4]   | passed | 0.00024 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:6:1]   | passed | 0.00069 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:6:2]   | passed | 0.00158 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:7:1]   | passed | 0.00158 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:7:2]   | passed | 0.00131 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:8:1]   | passed | 0.00045 seconds |
+./spec/sidekiq/queue_throttled/queue_limiter_spec.rb[1:8:2]   | passed | 0.0008 seconds  |
+./spec/sidekiq/queue_throttled/railtie_spec.rb[1:1:1]         | failed | 0.00014 seconds |
+./spec/sidekiq/queue_throttled/railtie_spec.rb[1:1:2]         | failed | 0.00011 seconds |
+./spec/sidekiq/queue_throttled/railtie_spec.rb[1:1:3]         | failed | 0.00011 seconds |
+./spec/sidekiq/queue_throttled/railtie_spec.rb[1:2:1]         | failed | 0.00128 seconds |
+./spec/sidekiq/queue_throttled/railtie_spec.rb[1:2:2]         | failed | 0.00021 seconds |

data/spec/sidekiq/queue_throttled/queue_limiter_spec.rb

@@ -25,17 +25,17 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
     end
   end
 
-  describe '#acquire_lock' do
+  describe '#acquire_lock?' do
     it 'acquires lock when under limit' do
-      lock_id = limiter.acquire_lock
+      lock_id = limiter.acquire_lock?
       expect(lock_id).to be_truthy
       expect(limiter.current_count).to eq(1)
     end
 
     it 'acquires multiple locks up to limit' do
-      lock1 = limiter.acquire_lock
-      lock2 = limiter.acquire_lock
-      lock3 = limiter.acquire_lock
+      lock1 = limiter.acquire_lock?
+      lock2 = limiter.acquire_lock?
+      lock3 = limiter.acquire_lock?
 
       expect(lock1).to be_truthy
       expect(lock2).to be_truthy
@@ -44,31 +44,31 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
     end
 
     it 'fails to acquire lock when at limit' do
-      limiter.acquire_lock
-      limiter.acquire_lock
-      limiter.acquire_lock
+      limiter.acquire_lock?
+      limiter.acquire_lock?
+      limiter.acquire_lock?
 
-      lock4 = limiter.acquire_lock
+      lock4 = limiter.acquire_lock?
       expect(lock4).to be_falsey
       expect(limiter.current_count).to eq(3)
     end
 
     it 'uses provided worker_id' do
       worker_id = 'worker_123'
-      lock_id = limiter.acquire_lock(worker_id)
+      lock_id = limiter.acquire_lock?(worker_id)
       expect(lock_id).to include(worker_id)
     end
 
     it 'generates unique lock_id for each call' do
-      lock1 = limiter.acquire_lock
-      lock2 = limiter.acquire_lock
+      lock1 = limiter.acquire_lock?
+      lock2 = limiter.acquire_lock?
       expect(lock1).not_to eq(lock2)
     end
   end
 
   describe '#release_lock' do
     it 'releases lock and decrements counter' do
-      lock_id = limiter.acquire_lock
+      lock_id = limiter.acquire_lock?
       expect(limiter.current_count).to eq(1)
 
       result = limiter.release_lock(lock_id)
@@ -90,7 +90,7 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
     it 'handles redis errors gracefully' do
       allow(limiter.redis).to receive(:del).and_raise(Redis::BaseError.new('Connection error'))
 
-      lock_id = limiter.acquire_lock
+      lock_id = limiter.acquire_lock?
       result = limiter.release_lock(lock_id)
       expect(result).to be_truthy
     end
@@ -102,14 +102,14 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
     end
 
     it 'returns correct count after acquiring locks' do
-      limiter.acquire_lock
-      limiter.acquire_lock
+      limiter.acquire_lock?
+      limiter.acquire_lock?
       expect(limiter.current_count).to eq(2)
     end
 
     it 'returns correct count after releasing locks' do
-      lock1 = limiter.acquire_lock
-      limiter.acquire_lock
+      lock1 = limiter.acquire_lock?
+      limiter.acquire_lock?
       limiter.release_lock(lock1)
       expect(limiter.current_count).to eq(2)
     end
@@ -121,14 +121,14 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
     end
 
     it 'returns correct available slots after acquiring locks' do
-      limiter.acquire_lock
+      limiter.acquire_lock?
       expect(limiter.available_slots).to eq(2)
     end
 
     it 'returns 0 when at limit' do
-      limiter.acquire_lock
-      limiter.acquire_lock
-      limiter.acquire_lock
+      limiter.acquire_lock?
+      limiter.acquire_lock?
+      limiter.acquire_lock?
       expect(limiter.available_slots).to eq(0)
     end
 
@@ -141,7 +141,7 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
 
   describe '#reset!' do
     it 'resets counter and lock' do
-      limiter.acquire_lock
+      limiter.acquire_lock?
       expect(limiter.current_count).to eq(1)
 
       limiter.reset!
@@ -149,13 +149,13 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
     end
 
     it 'allows acquiring locks after reset' do
-      limiter.acquire_lock
-      limiter.acquire_lock
-      limiter.acquire_lock
+      limiter.acquire_lock?
+      limiter.acquire_lock?
+      limiter.acquire_lock?
       expect(limiter.current_count).to eq(3)
 
       limiter.reset!
-      lock_id = limiter.acquire_lock
+      lock_id = limiter.acquire_lock?
       expect(lock_id).to be_truthy
       expect(limiter.current_count).to eq(1)
     end
@@ -168,7 +168,7 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
 
       5.times do
         threads << Thread.new do
-          lock_id = limiter.acquire_lock
+          lock_id = limiter.acquire_lock?
           lock_ids << lock_id if lock_id
         end
       end
@@ -183,7 +183,7 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
 
     it 'handles concurrent releases' do
       lock_ids = []
-      3.times { lock_ids << limiter.acquire_lock }
+      3.times { lock_ids << limiter.acquire_lock? }
 
       threads = lock_ids.map do |lock_id|
         Thread.new do
@@ -199,7 +199,7 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
 
   describe 'redis key management' do
     it 'uses correct redis key prefix' do
-      limiter.acquire_lock
+      limiter.acquire_lock?
 
       # Check that the counter key exists with correct prefix
       keys = limiter.redis.keys("sidekiq:queue_throttled:queue:#{queue_name}:*")
@@ -207,7 +207,7 @@ RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
     end
 
     it 'sets TTL on counter keys' do
-      limiter.acquire_lock
+      limiter.acquire_lock?
 
       counter_key = "#{Sidekiq::QueueThrottled.configuration.redis_key_prefix}:queue:#{queue_name}:counter"
       ttl = limiter.redis.ttl(counter_key)

data/spec/sidekiq/queue_throttled/railtie_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Rails Integration' do
+  describe 'when Rails is available' do
+    before do
+      # Mock Rails to simulate Rails environment
+      stub_const('Rails', double('Rails'))
+      stub_const('Rails::Railtie', Class.new)
+
+      # Reload the main file to trigger Rails detection
+      load File.expand_path('../../lib/sidekiq/queue_throttled.rb', __dir__)
+    end
+
+    it 'defines the Sidekiq::QueueThrottled module' do
+      expect(defined?(Sidekiq::QueueThrottled)).to be_truthy
+    end
+
+    it 'defines the Sidekiq::QueueThrottled::Job module' do
+      expect(defined?(Sidekiq::QueueThrottled::Job)).to be_truthy
+    end
+
+    it 'defines the Railtie class' do
+      expect(defined?(Sidekiq::QueueThrottled::Railtie)).to be_truthy
+    end
+  end
+
+  describe 'when Rails is not available' do
+    before do
+      # Remove Rails constants to simulate non-Rails environment
+      Object.send(:remove_const, 'Rails') if defined?(Rails)
+
+      # Reload the main file to trigger Rails detection
+      load File.expand_path('../../lib/sidekiq/queue_throttled.rb', __dir__)
+    end
+
+    it 'still defines the Sidekiq::QueueThrottled module' do
+      expect(defined?(Sidekiq::QueueThrottled)).to be_truthy
+    end
+
+    it 'still defines the Sidekiq::QueueThrottled::Job module' do
+      expect(defined?(Sidekiq::QueueThrottled::Job)).to be_truthy
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -6,10 +6,10 @@ require 'rspec'
 require 'timecop'
 require 'pry'
 
-# Set up real Redis with password for tests
-redis_url = ENV['REDIS_URL'] || 'redis://:123123@localhost:6379/0'
+# Set up Redis for tests - use passwordless Redis for CI, passworded for local dev
+redis_url = ENV['REDIS_URL'] || 'redis://localhost:6379/0'
 
-# Configure Sidekiq to use Redis with password
+# Configure Sidekiq to use Redis
 Sidekiq.configure_client { |c| c.redis = { url: redis_url } }
 Sidekiq.configure_server { |c| c.redis = { url: redis_url } }
 Sidekiq::QueueThrottled.redis = Redis.new(url: redis_url)
@@ -63,7 +63,7 @@ module TestHelpers
     klass
   end
 
-  def wait_for_condition(timeout = 5, &condition)
+  def wait_for_condition?(timeout = 5, &condition)
     start_time = Time.now
     while Time.now - start_time < timeout
       return true if condition.call

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-queue-throttled
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.4
 platform: ruby
 authors:
 - Farid Mohammadi
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-30 00:00:00.000000000 Z
+date: 2025-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -70,6 +70,7 @@ files:
 - lib/sidekiq/queue_throttled/job_throttler.rb
 - lib/sidekiq/queue_throttled/middleware.rb
 - lib/sidekiq/queue_throttled/queue_limiter.rb
+- lib/sidekiq/queue_throttled/railtie.rb
 - lib/sidekiq/queue_throttled/version.rb
 - spec/examples.txt
 - spec/sidekiq/queue_throttled/configuration_spec.rb
@@ -77,14 +78,15 @@ files:
 - spec/sidekiq/queue_throttled/job_throttler_spec.rb
 - spec/sidekiq/queue_throttled/middleware_spec.rb
 - spec/sidekiq/queue_throttled/queue_limiter_spec.rb
+- spec/sidekiq/queue_throttled/railtie_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/faridmohammadi/sidekiq-queue-throttled
+homepage: https://github.com/zilnex/sidekiq-queue-throttled
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/faridmohammadi/sidekiq-queue-throttled
-  source_code_uri: https://github.com/faridmohammadi/sidekiq-queue-throttled
-  changelog_uri: https://github.com/faridmohammadi/sidekiq-queue-throttled/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/zilnex/sidekiq-queue-throttled
+  source_code_uri: https://github.com/zilnex/sidekiq-queue-throttled
+  changelog_uri: https://github.com/zilnex/sidekiq-queue-throttled/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []