shoryuken 7.0.2 → 7.0.4

data/spec/integrations_helper.rb

@@ -2,12 +2,15 @@
 
 # Integration test helper for process-isolated testing
 
-# Enable Ruby warnings to catch deprecations and potential issues
-Warning[:performance] = true if RUBY_VERSION >= '3.3'
-Warning[:deprecated] = true
+require 'warning'
+
 $VERBOSE = true
 
-require 'warning'
+if Warning.respond_to?(:categories)
+  (Warning.categories - %i[experimental]).each do |cat|
+    Warning[cat] = true
+  end
+end
 
 # Process warnings and raise on unexpected ones from our code
 Warning.process do |warning|
@@ -17,10 +20,6 @@ Warning.process do |warning|
   # Filter out warnings we don't care about in specs
   next if warning.include?('_spec')
 
-  # We redefine methods to simulate various scenarios in tests
-  next if warning.include?('previous definition of')
-  next if warning.include?('method redefined')
-
   # Ignore vendor directory
   next if warning.include?('vendor/')
 
@@ -191,7 +190,9 @@ module IntegrationsHelper
     launcher.start
     Timeout.timeout(timeout) { sleep 0.5 until yield }
   ensure
-    launcher.stop
+    # Guard stop with a hard deadline so a stuck dispatch thread (e.g. an SQS
+    # HTTP call that never returns) can't block the spec process forever.
+    Timeout.timeout(30) { launcher.stop }
   end
 
   # Simple mock object

data/spec/lib/shoryuken/client_spec.rb

@@ -17,5 +17,67 @@ RSpec.describe Shoryuken::Client do
       expect(Shoryuken::Client.queues(queue_name).url).to eq queue_url
       expect(Shoryuken::Client.queues(queue_name).url).to eq queue_url
     end
+
+    it 'constructs each queue only once under concurrent first access' do
+      allow(described_class).to receive(:sqs).and_return(sqs)
+
+      construction_count = Shoryuken::Helpers::AtomicCounter.new(0)
+      allow(Shoryuken::Queue).to receive(:new) do
+        construction_count.increment
+        # Mimic the SQS API latency during construction. sleep releases the GVL,
+        # so without synchronization every concurrent caller builds its own queue.
+        sleep 0.05
+        instance_double(Shoryuken::Queue)
+      end
+
+      threads = Array.new(10) { Thread.new { described_class.queues('concurrent') } }
+      threads.each(&:join)
+
+      expect(construction_count.value).to eq(1)
+    end
+
+    it 'rebuilds cached queues after the sqs client is replaced' do
+      allow(described_class).to receive(:sqs).and_return(sqs)
+
+      construction_count = Shoryuken::Helpers::AtomicCounter.new(0)
+      allow(Shoryuken::Queue).to receive(:new) do
+        construction_count.increment
+        instance_double(Shoryuken::Queue)
+      end
+
+      described_class.queues(queue_name)
+      described_class.queues(queue_name)
+      expect(construction_count.value).to eq(1)
+
+      described_class.sqs = sqs
+
+      described_class.queues(queue_name)
+      expect(construction_count.value).to eq(2)
+    end
+
+    it 'does not cache a queue built with the previous client while it is being replaced' do
+      old_sqs = :old_client
+      new_sqs = :new_client
+
+      described_class.sqs = old_sqs
+
+      allow(Shoryuken::Queue).to receive(:new) do |client, _name|
+        instance_double(Shoryuken::Queue, client: client)
+      end
+
+      # Widen the window between resetting the cache and installing the new client so a concurrent
+      # `queues` call would cache a queue built with the old client unless the swap is atomic.
+      allow(Shoryuken).to receive(:sqs_client=).and_wrap_original do |original, client|
+        sleep 0.05
+        original.call(client)
+      end
+
+      replacer = Thread.new { described_class.sqs = new_sqs }
+      sleep 0.01
+      reader = Thread.new { described_class.queues('concurrent') }
+      [replacer, reader].each(&:join)
+
+      expect(described_class.queues('concurrent').client).to eq(new_sqs)
+    end
   end
 end

data/spec/lib/shoryuken/fetcher_spec.rb

@@ -113,6 +113,19 @@ RSpec.describe Shoryuken::Fetcher do
         subject.fetch(queue_config, limit)
       end
 
+      it 'caps at one message even when the queue config requests more' do
+        # A custom polling strategy can put max_number_of_messages in the
+        # QueueConfiguration options; the FIFO one-at-a-time guard must still win
+        # so SQS can't return several messages from the same group.
+        config = Shoryuken::Polling::QueueConfiguration.new(queue_name, max_number_of_messages: 10)
+
+        allow(Shoryuken::Client).to receive(:queues).with(queue_name).and_return(queue)
+        expect(queue).to receive(:receive_messages)
+          .with(hash_including(max_number_of_messages: 1)).and_return([])
+
+        subject.fetch(config, limit)
+      end
+
       context 'with batch=true' do
         it 'polls the provided limit' do
           # see https://github.com/ruby-shoryuken/shoryuken/pull/530

data/spec/lib/shoryuken/helpers/timer_task_spec.rb

@@ -295,4 +295,28 @@ RSpec.describe Shoryuken::Helpers::TimerTask do
       expect(false_count).to eq(4)
     end
   end
+
+  describe 'thread priority' do
+    it 'does not inherit a lowered priority from the creating thread' do
+      observed = ::Queue.new
+
+      # Shoryuken starts the visibility-extension timer from a worker thread
+      # whose priority is lowered to Shoryuken.thread_priority (default -1).
+      # The timer thread must not inherit that lowered priority, otherwise a
+      # delayed extension under load can miss the visibility timeout and let the
+      # message be redelivered (double processed).
+      creator = Thread.new do
+        Thread.current.priority = -1
+        timer = described_class.new(execution_interval: 0.05) do
+          observed << Thread.current.priority
+        end
+        timer.execute
+        sleep(0.15)
+        timer.kill
+      end
+      creator.join
+
+      expect(observed.pop).to eq(0)
+    end
+  end
 end

data/spec/lib/shoryuken/launcher_spec.rb

@@ -78,6 +78,22 @@ RSpec.describe Shoryuken::Launcher do
       expect(first_group_manager).to have_received(:stop_new_dispatching)
       expect(second_group_manager).to have_received(:stop_new_dispatching)
     end
+
+    it 'bounds the wait for termination by the configured timeout' do
+      allow(executor).to receive(:shutdown)
+      expect(executor).to receive(:wait_for_termination).with(Shoryuken.options[:timeout]).and_return(true)
+      expect(executor).not_to receive(:kill)
+
+      subject.stop
+    end
+
+    it 'kills the executor when workers do not finish within the timeout' do
+      allow(executor).to receive(:shutdown)
+      allow(executor).to receive(:wait_for_termination).and_return(false)
+      expect(executor).to receive(:kill)
+
+      subject.stop
+    end
   end
 
   describe '#stop!' do
@@ -102,6 +118,28 @@ RSpec.describe Shoryuken::Launcher do
     end
   end
 
+  describe 'executor ownership' do
+    context 'when no launcher_executor is configured' do
+      before { allow(Shoryuken).to receive(:launcher_executor).and_return(nil) }
+
+      it 'uses a dedicated executor rather than the process-global IO executor' do
+        expect(subject.send(:executor)).not_to be(Concurrent.global_io_executor)
+      end
+
+      it 'does not shut down or kill the global IO executor on stop!' do
+        allow(first_group_manager).to receive(:stop_new_dispatching)
+        allow(second_group_manager).to receive(:stop_new_dispatching)
+
+        subject.stop!
+
+        # Verify by inspecting state after the call rather than mocking methods
+        # on the process-global singleton: RSpec proxies on a singleton used by
+        # background concurrent-ruby threads can deadlock on Ruby 3.2.
+        expect(Concurrent.global_io_executor).to be_running
+      end
+    end
+  end
+
   describe '#stopping?' do
     it 'returns false by default' do
       expect(subject.stopping?).to be false

data/spec/lib/shoryuken/manager_spec.rb

@@ -34,6 +34,50 @@ RSpec.describe Shoryuken::Manager do
     end
   end
 
+  describe '#await_dispatching_in_progress' do
+    it 'returns for repeated graceful stops (e.g. TSTP followed by USR1)' do
+      subject.stop_new_dispatching
+      # The dispatch loop observes the stop flag and releases all waiters
+      subject.start
+
+      waiter = Thread.new do
+        subject.await_dispatching_in_progress
+        subject.await_dispatching_in_progress
+      end
+
+      expect(waiter.join(5)).to eq(waiter), 'await_dispatching_in_progress deadlocked on a repeated stop'
+    end
+
+    it 'returns when stopped before the dispatch loop ever runs' do
+      # No #start here: the dispatch loop never runs, so there is nothing to
+      # observe the stop flag and close the signal - stop_new_dispatching must
+      # release waiters itself.
+      subject.stop_new_dispatching
+
+      waiter = Thread.new { subject.await_dispatching_in_progress }
+
+      expect(waiter.join(5)).to eq(waiter), 'await_dispatching_in_progress deadlocked when start never ran'
+    end
+
+    context 'when the executor rejects the dispatch post' do
+      let(:executor) do
+        double('executor', running?: true).tap do |rejecting_executor|
+          allow(rejecting_executor).to receive(:post).and_raise(Concurrent::RejectedExecutionError)
+        end
+      end
+
+      it 'releases waiters instead of leaving the signal queue unsignaled' do
+        # A hard stop can shut the executor down between the running? check and
+        # the post; the dispatch chain must still release stop waiters
+        subject.start
+
+        waiter = Thread.new { subject.await_dispatching_in_progress }
+
+        expect(waiter.join(5)).to eq(waiter), 'await_dispatching_in_progress deadlocked after a rejected post'
+      end
+    end
+  end
+
   describe '#start' do
     before do
       # prevent dispatch loop
@@ -153,6 +197,81 @@ RSpec.describe Shoryuken::Manager do
     end
   end
 
+  describe '#assign' do
+    let(:sqs_msg) { double(Shoryuken::Message, message_id: SecureRandom.uuid) }
+    let(:sqs_queue) { double(Shoryuken::Queue, fifo?: false) }
+
+    before do
+      allow(Shoryuken::Client).to receive(:queues).with(queue).and_return(sqs_queue)
+      allow(Shoryuken::Processor).to receive(:process)
+    end
+
+    it 'runs completion exactly once on success' do
+      expect(subject).to receive(:processor_done).with(queue).once.and_call_original
+
+      subject.send(:assign, queue, sqs_msg)
+
+      expect(subject.send(:busy)).to eq(0)
+    end
+
+    it 'runs completion exactly once when processing raises' do
+      allow(Shoryuken::Processor).to receive(:process).and_raise('processing failed')
+
+      expect(subject).to receive(:processor_done).with(queue).once.and_call_original
+
+      subject.send(:assign, queue, sqs_msg)
+
+      expect(subject.send(:busy)).to eq(0)
+    end
+
+    it 'does not double decrement the busy counter when completion raises' do
+      allow(sqs_queue).to receive(:fifo?).and_return(true)
+      allow(polling_strategy).to receive(:message_processed).and_raise('callback failed')
+
+      subject.send(:assign, queue, sqs_msg)
+
+      expect(polling_strategy).to have_received(:message_processed).once
+      expect(subject.send(:busy)).to eq(0)
+    end
+
+    context 'when the executor rejects the worker post' do
+      # A real ExecutorService instance (Concurrent::Promise validates the
+      # executor type), with running? stubbed true so #assign proceeds past its
+      # guard and post rejecting - exactly the shutdown race / saturated
+      # bounded launcher_executor case. ImmediateExecutor spawns no background
+      # thread, so nothing lingers at teardown.
+      let(:executor) do
+        Concurrent::ImmediateExecutor.new.tap do |rejecting_executor|
+          allow(rejecting_executor).to receive(:running?).and_return(true)
+          allow(rejecting_executor).to receive(:post).and_raise(Concurrent::RejectedExecutionError)
+        end
+      end
+
+      it 'rolls back the busy counter and does not leak it' do
+        # The promise body never runs, so completion must not run either
+        # (decrement directly, and no FIFO message_processed callback).
+        expect(subject).not_to receive(:processor_done)
+
+        expect { subject.send(:assign, queue, sqs_msg) }.not_to raise_error
+
+        expect(subject.send(:busy)).to eq(0)
+      end
+
+      it 'does not run the FIFO message_processed callback' do
+        # The message was never processed, so the rejection rollback must
+        # decrement directly and never reach the FIFO bookkeeping - even for a
+        # FIFO queue. Guards against a refactor routing rollback through
+        # processor_done.
+        allow(sqs_queue).to receive(:fifo?).and_return(true)
+        expect(polling_strategy).not_to receive(:message_processed)
+
+        subject.send(:assign, queue, sqs_msg)
+
+        expect(subject.send(:busy)).to eq(0)
+      end
+    end
+  end
+
   describe '#processor_done' do
     let(:sqs_queue)         { double Shoryuken::Queue }
 
@@ -177,6 +296,34 @@ RSpec.describe Shoryuken::Manager do
     end
   end
 
+  describe '#handle_dispatch_error' do
+    let(:error) { StandardError.new('boom') }
+
+    context 'when running under the CLI (server mode)' do
+      before { allow(Shoryuken).to receive(:server?).and_return(true) }
+
+      it 'stops the manager and signals the process to shut down' do
+        expect(Process).to receive(:kill).with('USR1', Process.pid)
+
+        subject.send(:handle_dispatch_error, error)
+
+        expect(subject.running?).to be false
+      end
+    end
+
+    context 'when embedded (no Runner)' do
+      before { allow(Shoryuken).to receive(:server?).and_return(false) }
+
+      it 'stops the manager without signalling the process' do
+        expect(Process).not_to receive(:kill)
+
+        subject.send(:handle_dispatch_error, error)
+
+        expect(subject.running?).to be false
+      end
+    end
+  end
+
   describe '#running?' do
     context 'when the executor is running' do
       before do

data/spec/lib/shoryuken/middleware/server/auto_extend_visibility_spec.rb

@@ -114,4 +114,39 @@ RSpec.describe Shoryuken::Middleware::Server::AutoExtendVisibility do
       Runner.new.run_and_sleep(TestWorker.new, queue, sqs_msg, visibility_timeout)
     end
   end
+
+  context 'when the visibility timeout is too short for the upfront margin' do
+    # interval would be visibility_timeout - extend_upfront == 0, which used to
+    # make TimerTask raise before the worker ran.
+    let(:visibility_timeout) { extend_upfront }
+
+    it 'runs the worker instead of raising' do
+      TestWorker.get_shoryuken_options['auto_visibility_timeout'] = true
+      allow(sqs_msg).to receive(:queue) { sqs_queue }
+      allow(sqs_msg).to receive(:message_id).and_return('test-message-id')
+      allow(sqs_msg).to receive(:change_visibility)
+
+      ran = false
+      subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { ran = true }
+
+      expect(ran).to be true
+    end
+  end
+
+  context 'when the visibility timeout is zero' do
+    let(:visibility_timeout) { 0 }
+
+    it 'warns and runs the worker without scheduling an extension' do
+      TestWorker.get_shoryuken_options['auto_visibility_timeout'] = true
+      allow(sqs_msg).to receive(:queue) { sqs_queue }
+      allow(sqs_msg).to receive(:message_id).and_return('test-message-id')
+      expect(sqs_msg).not_to receive(:change_visibility)
+      expect(Shoryuken.logger).to receive(:warn)
+
+      ran = false
+      subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { ran = true }
+
+      expect(ran).to be true
+    end
+  end
 end

data/spec/lib/shoryuken/middleware/server/exponential_backoff_retry_spec.rb

@@ -17,6 +17,21 @@ RSpec.describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do
     it 'yields' do
       expect { |b| subject.call(TestWorker.new, nil, [], nil, &b) }.to yield_control
     end
+
+    it 'does not mask the original error when the batch raises' do
+      TestWorker.get_shoryuken_options['retry_intervals'] = [300]
+
+      # Use a logger that actually evaluates lazy log blocks (StringIO, not
+      # IO::NULL which skips them), as the default production level does - so a
+      # stray message_id/attributes call on the batch Array would surface.
+      # Batches aren't backoff-retried, so the original error must propagate
+      # rather than a NoMethodError from calling message APIs on the Array.
+      allow(subject).to receive(:logger).and_return(Logger.new(StringIO.new, level: Logger::DEBUG))
+
+      expect {
+        subject.call(TestWorker.new, nil, [sqs_msg], nil) { raise 'original batch error' }
+      }.to raise_error(RuntimeError, 'original batch error')
+    end
   end
 
   context 'when no exception' do
@@ -92,6 +107,62 @@ RSpec.describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do
 
         expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' } }.not_to raise_error
       end
+
+      it 'keeps reusing the last interval for far-later attempts (does not give up)' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+
+        allow(sqs_msg).to receive(:attributes) { { 'ApproximateReceiveCount' => 10 } }
+        allow(sqs_msg).to receive(:queue) { sqs_queue }
+        expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 1800)
+
+        expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' } }.not_to raise_error
+      end
+    end
+
+    context 'and the exception is non-retryable' do
+      it 're-raises so NonRetryableException can delete the message' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+        TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [ArgumentError]
+
+        expect(sqs_msg).not_to receive(:change_visibility)
+
+        expect {
+          subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise ArgumentError, 'permanently invalid' }
+        }.to raise_error(ArgumentError, 'permanently invalid')
+      end
+
+      it 're-raises when a non_retryable_exceptions lambda returns true' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+        TestWorker.get_shoryuken_options['non_retryable_exceptions'] = ->(e) { e.message.include?('permanent') }
+
+        expect(sqs_msg).not_to receive(:change_visibility)
+
+        expect {
+          subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'permanent failure' }
+        }.to raise_error(RuntimeError, 'permanent failure')
+      end
+
+      it 'still retries when a non_retryable_exceptions lambda returns false' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+        TestWorker.get_shoryuken_options['non_retryable_exceptions'] = ->(e) { e.message.include?('permanent') }
+
+        allow(sqs_msg).to receive(:queue) { sqs_queue }
+        expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 300)
+
+        expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'transient failure' } }
+          .not_to raise_error
+      end
+
+      it 'still retries exceptions not in the non-retryable list' do
+        TestWorker.get_shoryuken_options['retry_intervals'] = [300, 1800]
+        TestWorker.get_shoryuken_options['non_retryable_exceptions'] = [ArgumentError]
+
+        allow(sqs_msg).to receive(:queue) { sqs_queue }
+        expect(sqs_msg).to receive(:change_visibility).with(visibility_timeout: 300)
+
+        expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'transient failure' } }
+          .not_to raise_error
+      end
     end
 
     it 'limits the visibility timeout to 12 hours' do
@@ -102,5 +173,22 @@ RSpec.describe Shoryuken::Middleware::Server::ExponentialBackoffRetry do
 
       expect { subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'failed' } }.not_to raise_error
     end
+
+    it 'never sets a negative visibility timeout for jobs longer than the SQS ceiling' do
+      started_at = Time.now - 43_300 # ran longer than the 12h SQS maximum
+
+      expect(subject.send(:next_visibility_timeout, 300, started_at)).to eq(0)
+    end
+
+    it 'does not mask the original error when rescheduling fails' do
+      TestWorker.get_shoryuken_options['retry_intervals'] = [300]
+
+      # e.g. an expired receipt handle - change_visibility raises
+      allow(sqs_msg).to receive(:change_visibility).and_raise(StandardError, 'visibility boom')
+
+      expect {
+        subject.call(TestWorker.new, queue, sqs_msg, sqs_msg.body) { raise 'original worker error' }
+      }.to raise_error(RuntimeError, 'original worker error')
+    end
   end
 end

data/spec/lib/shoryuken/polling/strict_priority_spec.rb

@@ -155,4 +155,29 @@ RSpec.describe Shoryuken::Polling::StrictPriority do
       expect(strategy.active_queues).to eq([[queue1, 2], [queue2, 1]])
     end
   end
+
+  describe 'thread safety' do
+    it 'serializes concurrent next_queue, messages_found and message_processed' do
+      strategy = Shoryuken::Polling::StrictPriority.new([queue1, queue2], 10)
+
+      errors = []
+      errors_mutex = Mutex.new
+
+      threads = Array.new(6) do
+        Thread.new do
+          50.times do |i|
+            strategy.next_queue
+            strategy.messages_found(queue1, i.even? ? 0 : 1)
+            strategy.message_processed(queue1)
+            strategy.active_queues
+          end
+        rescue => e
+          errors_mutex.synchronize { errors << e }
+        end
+      end
+      threads.each(&:join)
+
+      expect(errors).to be_empty
+    end
+  end
 end

data/spec/lib/shoryuken/polling/weighted_round_robin_spec.rb

@@ -138,5 +138,55 @@ RSpec.describe Shoryuken::Polling::WeightedRoundRobin do
       expect(subject.next_queue).to eq(queue1) # implicitly unpauses queue2
       expect(subject.active_queues).to eq([[queue1, 2], [queue2, 1]])
     end
+
+    it 'unpauses a processed queue stuck behind an earlier-paused queue' do
+      queues << queue1
+      queues << queue2
+
+      allow(subject).to receive(:delay).and_return(10)
+      now = Time.now
+      allow(Time).to receive(:now).and_return(now)
+
+      subject.messages_found(queue1, 0) # queue1 paused until now + 10
+
+      now += 1
+      allow(Time).to receive(:now).and_return(now)
+      subject.messages_found(queue2, 0) # queue2 paused until now + 10 (after queue1)
+
+      # both queues paused, nothing pollable yet
+      expect(subject.next_queue).to eq(nil)
+
+      # queue2 finishes processing and is marked ready while queue1 is still paused
+      subject.message_processed(queue2)
+
+      # queue2 must be pollable even though the earlier-paused queue1 is still paused
+      expect(subject.next_queue).to eq(queue2)
+    end
+  end
+
+  describe 'thread safety' do
+    it 'serializes concurrent next_queue, messages_found and message_processed' do
+      queues << queue1
+      queues << queue2
+
+      errors = []
+      errors_mutex = Mutex.new
+
+      threads = Array.new(6) do
+        Thread.new do
+          50.times do |i|
+            subject.next_queue
+            subject.messages_found(queue1, i.even? ? 0 : 1)
+            subject.message_processed(queue1)
+            subject.active_queues
+          end
+        rescue => e
+          errors_mutex.synchronize { errors << e }
+        end
+      end
+      threads.each(&:join)
+
+      expect(errors).to be_empty
+    end
   end
 end