sidekiq-queue-throttled 1.0.0

data/spec/sidekiq/queue_throttled/middleware_spec.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Sidekiq::QueueThrottled::Middleware do
+  let(:middleware) { described_class.new }
+  let(:worker) { double('worker', class: worker_class) }
+  let(:worker_class) { double('worker_class', name: 'TestWorker') }
+  let(:job) { { 'queue' => 'test_queue', 'args' => [123] } }
+  let(:queue) { 'test_queue' }
+
+  before do
+    Sidekiq::QueueThrottled.configuration.set_queue_limit('test_queue', 2)
+  end
+
+  describe '#call' do
+    context 'without queue limits or job throttling' do
+      it 'processes job normally' do
+        processed = false
+        middleware.call(worker, job, queue) do
+          processed = true
+        end
+        expect(processed).to be_truthy
+      end
+    end
+
+    context 'with queue limits' do
+      before do
+        Sidekiq::QueueThrottled.configuration.set_queue_limit('test_queue', 1)
+      end
+
+      it 'processes job when under limit' do
+        processed = false
+        middleware.call(worker, job, queue) do
+          processed = true
+        end
+        expect(processed).to be_truthy
+      end
+
+      it 'reschedules job when at limit' do
+        # First job should process
+        processed1 = false
+        middleware.call(worker, job, queue) do
+          processed1 = true
+        end
+        expect(processed1).to be_truthy
+
+        # Second job should be rescheduled
+        processed2 = false
+        middleware.call(worker, job, queue) do
+          processed2 = true
+        end
+        expect(processed2).to be_falsey
+
+        # Check that job was rescheduled
+        scheduled_jobs = Sidekiq.redis { |conn| conn.zrange('schedule', 0, -1) }
+        expect(scheduled_jobs).not_to be_empty
+      end
+    end
+
+    context 'with job throttling' do
+      let(:worker_class) do
+        create_test_job_class('ThrottledWorker') do
+          sidekiq_throttle(
+            concurrency: {
+              limit: 1,
+              key_suffix: ->(user_id) { user_id }
+            }
+          )
+        end
+      end
+
+      it 'processes job when under throttle limit' do
+        processed = false
+        middleware.call(worker, job, queue) do
+          processed = true
+        end
+        expect(processed).to be_truthy
+      end
+
+      it 'reschedules job when at throttle limit' do
+        # First job should process
+        processed1 = false
+        middleware.call(worker, job, queue) do
+          processed1 = true
+        end
+        expect(processed1).to be_truthy
+
+        # Second job with same user_id should also process (sequential, not concurrent)
+        processed2 = false
+        middleware.call(worker, job, queue) do
+          processed2 = true
+        end
+        expect(processed2).to be_truthy
+
+        # There should be no scheduled jobs
+        scheduled_jobs = Sidekiq.redis { |conn| conn.zrange('schedule', 0, -1) }
+        expect(scheduled_jobs).to be_empty
+      end
+
+      it 'allows different user_ids' do
+        # First job with user_id 123
+        processed1 = false
+        middleware.call(worker, job, queue) do
+          processed1 = true
+        end
+        expect(processed1).to be_truthy
+
+        # Second job with user_id 456 should process
+        job2 = job.merge('args' => [456])
+        processed2 = false
+        middleware.call(worker, job2, queue) do
+          processed2 = true
+        end
+        expect(processed2).to be_truthy
+      end
+    end
+
+    context 'with both queue limits and job throttling' do
+      let(:worker_class) do
+        create_test_job_class('ThrottledWorker') do
+          sidekiq_throttle(
+            concurrency: {
+              limit: 2,
+              key_suffix: ->(user_id) { user_id }
+            }
+          )
+        end
+      end
+
+      before do
+        Sidekiq::QueueThrottled.configuration.set_queue_limit('test_queue', 1)
+      end
+
+      it 'respects queue limit first' do
+        # First job should process
+        processed1 = false
+        middleware.call(worker, job, queue) do
+          processed1 = true
+        end
+        expect(processed1).to be_truthy
+
+        # Second job should be rescheduled due to queue limit (not job throttle)
+        processed2 = false
+        middleware.call(worker, job, queue) do
+          processed2 = true
+        end
+        expect(processed2).to be_falsey
+      end
+    end
+
+    context 'error handling' do
+      it 'releases locks even when job raises error' do
+        Sidekiq::QueueThrottled.configuration.set_queue_limit('test_queue', 1)
+
+        expect do
+          middleware.call(worker, job, queue) do
+            raise 'Job error'
+          end
+        end.to raise_error('Job error')
+
+        # Reset the limiter to simulate a fresh state for the next job
+        limiter = middleware.send(:get_queue_limiter, queue)
+        limiter.reset!
+
+        # Should be able to process another job after error
+        processed = false
+        middleware.call(worker, job, queue) do
+          processed = true
+        end
+        expect(processed).to be_truthy
+      end
+
+      it 'releases job throttle slots even when job raises error' do
+        worker_class = create_test_job_class('ThrottledWorker') do
+          sidekiq_throttle(
+            concurrency: {
+              limit: 1,
+              key_suffix: ->(user_id) { user_id }
+            }
+          )
+        end
+        worker = double('worker', class: worker_class)
+
+        expect do
+          middleware.call(worker, job, queue) do
+            raise 'Job error'
+          end
+        end.to raise_error('Job error')
+
+        # Should be able to process another job after error
+        processed = false
+        middleware.call(worker, job, queue) do
+          processed = true
+        end
+        expect(processed).to be_truthy
+      end
+    end
+  end
+
+  describe '#get_queue_limiter' do
+    it 'returns nil for queue without limit' do
+      limiter = middleware.send(:get_queue_limiter, 'non_existent_queue')
+      expect(limiter).to be_nil
+    end
+
+    it 'returns limiter for queue with limit' do
+      limiter = middleware.send(:get_queue_limiter, 'test_queue')
+      expect(limiter).to be_a(Sidekiq::QueueThrottled::QueueLimiter)
+      expect(limiter.queue_name).to eq('test_queue')
+      expect(limiter.limit).to eq(2)
+    end
+
+    it 'caches limiters' do
+      limiter1 = middleware.send(:get_queue_limiter, 'test_queue')
+      limiter2 = middleware.send(:get_queue_limiter, 'test_queue')
+      expect(limiter1).to eq(limiter2)
+    end
+  end
+
+  describe '#get_job_throttler' do
+    it 'returns nil for job without throttle config' do
+      throttler = middleware.send(:get_job_throttler, 'TestWorker')
+      expect(throttler).to be_nil
+    end
+
+    it 'returns throttler for job with throttle config' do
+      create_test_job_class('ThrottledWorker') do
+        sidekiq_throttle(
+          concurrency: {
+            limit: 1,
+            key_suffix: ->(user_id) { user_id }
+          }
+        )
+      end
+
+      throttler = middleware.send(:get_job_throttler, 'ThrottledWorker')
+      expect(throttler).to be_a(Sidekiq::QueueThrottled::JobThrottler)
+      expect(throttler.job_class).to eq('ThrottledWorker')
+    end
+
+    it 'caches throttlers' do
+      create_test_job_class('ThrottledWorker') do
+        sidekiq_throttle(
+          concurrency: {
+            limit: 1,
+            key_suffix: ->(user_id) { user_id }
+          }
+        )
+      end
+
+      throttler1 = middleware.send(:get_job_throttler, 'ThrottledWorker')
+      throttler2 = middleware.send(:get_job_throttler, 'ThrottledWorker')
+      expect(throttler1).to eq(throttler2)
+    end
+  end
+
+  describe '#reschedule_job' do
+    it 'adds job to schedule with delay' do
+      middleware.send(:reschedule_job, job, queue)
+
+      scheduled_jobs = Sidekiq.redis { |conn| conn.zrange('schedule', 0, -1) }
+      expect(scheduled_jobs).not_to be_empty
+
+      scheduled_job = JSON.parse(scheduled_jobs.first)
+      expect(scheduled_job['queue']).to eq(queue)
+      expect(scheduled_job['args']).to eq([123])
+      expect(scheduled_job['at']).to be > Time.now.to_f
+    end
+
+    it 'uses configured retry delay' do
+      Sidekiq::QueueThrottled.configuration.retry_delay = 10
+      middleware.send(:reschedule_job, job, queue)
+
+      scheduled_jobs = Sidekiq.redis { |conn| conn.zrange('schedule', 0, -1) }
+      scheduled_job = JSON.parse(scheduled_jobs.first)
+      expect(scheduled_job['at']).to be_within(1).of(Time.now.to_f + 10)
+    end
+  end
+end

data/spec/sidekiq/queue_throttled/queue_limiter_spec.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Sidekiq::QueueThrottled::QueueLimiter do
+  let(:queue_name) { 'test_queue' }
+  let(:limit) { 3 }
+  let(:limiter) { described_class.new(queue_name, limit) }
+
+  describe '#initialize' do
+    it 'sets queue name and limit' do
+      expect(limiter.queue_name).to eq(queue_name)
+      expect(limiter.limit).to eq(limit)
+    end
+
+    it 'converts limit to integer' do
+      limiter = described_class.new(queue_name, '5')
+      expect(limiter.limit).to eq(5)
+    end
+
+    it 'uses provided redis connection' do
+      custom_redis = double('redis')
+      limiter = described_class.new(queue_name, limit, custom_redis)
+      expect(limiter.redis).to eq(custom_redis)
+    end
+  end
+
+  describe '#acquire_lock' do
+    it 'acquires lock when under limit' do
+      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
+
+      expect(lock1).to be_truthy
+      expect(lock2).to be_truthy
+      expect(lock3).to be_truthy
+      expect(limiter.current_count).to eq(3)
+    end
+
+    it 'fails to acquire lock when at limit' do
+      limiter.acquire_lock
+      limiter.acquire_lock
+      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)
+      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
+      expect(lock1).not_to eq(lock2)
+    end
+  end
+
+  describe '#release_lock' do
+    it 'releases lock and decrements counter' do
+      lock_id = limiter.acquire_lock
+      expect(limiter.current_count).to eq(1)
+
+      result = limiter.release_lock(lock_id)
+      expect(result).to be_truthy
+      expect(limiter.current_count).to eq(1)
+    end
+
+    it 'handles nil lock_id' do
+      result = limiter.release_lock(nil)
+      expect(result).to be_falsey
+    end
+
+    it 'handles non-existent lock_id' do
+      result = limiter.release_lock('non_existent')
+      expect(result).to be_truthy
+      expect(limiter.current_count).to eq(0)
+    end
+
+    it 'handles redis errors gracefully' do
+      allow(limiter.redis).to receive(:del).and_raise(Redis::BaseError.new('Connection error'))
+
+      lock_id = limiter.acquire_lock
+      result = limiter.release_lock(lock_id)
+      expect(result).to be_truthy
+    end
+  end
+
+  describe '#current_count' do
+    it 'returns 0 for new limiter' do
+      expect(limiter.current_count).to eq(0)
+    end
+
+    it 'returns correct count after acquiring locks' do
+      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
+      limiter.release_lock(lock1)
+      expect(limiter.current_count).to eq(2)
+    end
+  end
+
+  describe '#available_slots' do
+    it 'returns limit for new limiter' do
+      expect(limiter.available_slots).to eq(3)
+    end
+
+    it 'returns correct available slots after acquiring locks' do
+      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
+      expect(limiter.available_slots).to eq(0)
+    end
+
+    it 'never returns negative values' do
+      # Simulate a situation where counter might be higher than limit
+      allow(limiter.redis).to receive(:get).and_return('5')
+      expect(limiter.available_slots).to eq(0)
+    end
+  end
+
+  describe '#reset!' do
+    it 'resets counter and lock' do
+      limiter.acquire_lock
+      expect(limiter.current_count).to eq(1)
+
+      limiter.reset!
+      expect(limiter.current_count).to eq(0)
+    end
+
+    it 'allows acquiring locks after reset' do
+      limiter.acquire_lock
+      limiter.acquire_lock
+      limiter.acquire_lock
+      expect(limiter.current_count).to eq(3)
+
+      limiter.reset!
+      lock_id = limiter.acquire_lock
+      expect(lock_id).to be_truthy
+      expect(limiter.current_count).to eq(1)
+    end
+  end
+
+  describe 'concurrent access' do
+    it 'handles concurrent lock acquisitions' do
+      threads = []
+      lock_ids = []
+
+      5.times do
+        threads << Thread.new do
+          lock_id = limiter.acquire_lock
+          lock_ids << lock_id if lock_id
+        end
+      end
+
+      threads.each(&:join)
+
+      # Should only acquire 3 locks (the limit)
+      acquired_locks = lock_ids.compact
+      expect(acquired_locks.length).to eq(3)
+      expect(limiter.current_count).to eq(3)
+    end
+
+    it 'handles concurrent releases' do
+      lock_ids = []
+      3.times { lock_ids << limiter.acquire_lock }
+
+      threads = lock_ids.map do |lock_id|
+        Thread.new do
+          limiter.release_lock(lock_id)
+        end
+      end
+
+      threads.each(&:join)
+      # Counter should remain at 3 since we're using time-based limiting
+      expect(limiter.current_count).to eq(3)
+    end
+  end
+
+  describe 'redis key management' do
+    it 'uses correct redis key prefix' do
+      limiter.acquire_lock
+
+      # Check that the counter key exists with correct prefix
+      keys = limiter.redis.keys("sidekiq:queue_throttled:queue:#{queue_name}:*")
+      expect(keys).not_to be_empty
+    end
+
+    it 'sets TTL on counter keys' do
+      limiter.acquire_lock
+
+      counter_key = "#{Sidekiq::QueueThrottled.configuration.redis_key_prefix}:queue:#{queue_name}:counter"
+      ttl = limiter.redis.ttl(counter_key)
+      expect(ttl).to be > 0
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'sidekiq/queue_throttled'
+require 'rspec'
+require 'timecop'
+require 'pry'
+
+# Set up real Redis with password for tests
+redis_url = ENV['REDIS_URL'] || 'redis://:123123@localhost:6379/0'
+
+# Configure Sidekiq to use Redis with password
+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)
+
+# Configure RSpec
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+  config.disable_monkey_patching!
+  config.warnings = true
+
+  config.order = :random
+  Kernel.srand config.seed
+
+  # Reset Redis before each test
+  config.before(:each) do
+    Sidekiq::QueueThrottled.redis.flushdb
+    Sidekiq::QueueThrottled.configuration = Sidekiq::QueueThrottled::Configuration.new
+  end
+end
+
+# Helper methods for testing
+module TestHelpers
+  def create_test_job_class(name = 'TestJob', &block)
+    klass = Class.new do
+      include Sidekiq::Job
+      include Sidekiq::QueueThrottled::Job
+
+      define_method(:perform) do |*args|
+        # Default implementation
+      end
+
+      class_eval(&block) if block_given?
+    end
+
+    # Set the class name for better error messages and constant lookup
+    klass.define_singleton_method(:name) { name }
+
+    # Store the class in a constant so it can be looked up
+    Object.const_set(name, klass) unless Object.const_defined?(name)
+
+    klass
+  end
+
+  def wait_for_condition(timeout = 5, &condition)
+    start_time = Time.now
+    while Time.now - start_time < timeout
+      return true if condition.call
+
+      sleep 0.1
+    end
+    false
+  end
+end
+
+RSpec.configure do |config|
+  config.include TestHelpers
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-queue-throttled
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Farid Mohammadi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: A production-ready Sidekiq gem that provides both queue-level concurrency
+  limits and job-level throttling capabilities, combining the best of sidekiq-limit_fetch
+  and sidekiq-throttled.
+email:
+- farid.workspace@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/sidekiq/queue_throttled.rb
+- lib/sidekiq/queue_throttled/configuration.rb
+- lib/sidekiq/queue_throttled/job.rb
+- lib/sidekiq/queue_throttled/job_throttler.rb
+- lib/sidekiq/queue_throttled/middleware.rb
+- lib/sidekiq/queue_throttled/queue_limiter.rb
+- lib/sidekiq/queue_throttled/version.rb
+- spec/examples.txt
+- spec/sidekiq/queue_throttled/configuration_spec.rb
+- spec/sidekiq/queue_throttled/job_spec.rb
+- spec/sidekiq/queue_throttled/job_throttler_spec.rb
+- spec/sidekiq/queue_throttled/middleware_spec.rb
+- spec/sidekiq/queue_throttled/queue_limiter_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/faridmohammadi/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
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: Sidekiq gem that combines queue-level limits with job-level throttling
+test_files: []