shoryuken 7.0.3 → 7.0.4

data/lib/shoryuken/worker.rb

@@ -4,10 +4,9 @@ module Shoryuken
   # Worker module provides the core functionality for creating Shoryuken workers
   # that process messages from Amazon SQS queues.
   #
-  # Including this module in a class provides methods for configuring queue processing,
-  # enqueueing jobs, and setting up middleware. Workers can be configured for different
-  # processing patterns including single message processing, batch processing, and
-  # various retry and visibility timeout strategies.
+  # Including this module in a class provides methods for configuring queue processing, enqueueing jobs, and setting up
+  # middleware. Workers can be configured for different processing patterns including single message processing, batch
+  # processing, and various retry and visibility timeout strategies.
   #
   # @example Basic worker implementation
   #   class EmailWorker
@@ -123,7 +122,8 @@ module Shoryuken
       # @option opts [Boolean] :auto_delete (false) Automatically delete messages after processing
       # @option opts [Boolean] :auto_visibility_timeout (false) Automatically extend message visibility
       # @option opts [Array<Integer>] :retry_intervals Exponential backoff retry intervals in seconds
-      # @option opts [Array<Class>, Proc] :non_retryable_exceptions Exception classes or lambda that should skip retries and delete message immediately
+      # @option opts [Array<Class>, Proc] :non_retryable_exceptions Exception classes or lambda that should
+      #   skip retries and delete message immediately
       # @option opts [Hash] :sqs Additional SQS client options
       #
       # @example Basic worker configuration
@@ -216,9 +216,8 @@ module Shoryuken
         !!get_shoryuken_options['auto_visibility_timeout']
       end
 
-      # Checks if exponential backoff retry is configured for this worker.
-      # When retry intervals are specified, failed jobs will be retried with
-      # increasing delays between attempts.
+      # Checks if exponential backoff retry is configured for this worker. When retry intervals are specified, failed jobs
+      # will be retried with increasing delays between attempts.
       #
       # @return [Boolean] true if retry intervals are configured
       #
@@ -235,10 +234,9 @@ module Shoryuken
         !!get_shoryuken_options['retry_intervals']
       end
 
-      # Checks if automatic message deletion is enabled for this worker.
-      # When enabled, successfully processed messages are automatically deleted
-      # from the SQS queue. When disabled, you must manually delete messages
-      # or they will become visible again after the visibility timeout.
+      # Checks if automatic message deletion is enabled for this worker. When enabled, successfully processed messages are
+      # automatically deleted from the SQS queue. When disabled, you must manually delete messages or they will become
+      # visible again after the visibility timeout.
       #
       # @return [Boolean] true if auto delete is enabled
       #

data/lib/shoryuken.rb

@@ -27,9 +27,8 @@ module Shoryuken
     @_shoryuken_options ||= Shoryuken::Options.new
   end
 
-  # Checks if the Shoryuken server is running and healthy.
-  # A server is considered healthy when all configured processing groups
-  # are running and able to process messages.
+  # Checks if the Shoryuken server is running and healthy. A server is considered healthy when all configured processing
+  # groups are running and able to process messages.
   #
   # @return [Boolean] true if the server is healthy
   def self.healthy?
@@ -60,6 +59,8 @@ module Shoryuken
     :active_job_queue_name_prefixing=,
     :active_job_fifo_message_deduplication?,
     :active_job_fifo_message_deduplication=,
+    :fifo_message_deduplication?,
+    :fifo_message_deduplication=,
     :sqs_client,
     :sqs_client=,
     :sqs_client_receive_message_opts,

data/shoryuken.gemspec

@@ -11,6 +11,15 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/ruby-shoryuken/shoryuken'
   spec.license       = 'LGPL-3.0'
 
+  spec.metadata = {
+    'homepage_uri' => spec.homepage,
+    'source_code_uri' => spec.homepage,
+    'changelog_uri' => "#{spec.homepage}/blob/main/CHANGELOG.md",
+    'bug_tracker_uri' => "#{spec.homepage}/issues",
+    'documentation_uri' => spec.homepage,
+    'rubygems_mfa_required' => 'true'
+  }
+
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = %w[shoryuken]
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})

data/spec/integration/cli/find_all_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# `shoryuken sqs dump`/`mv` drain a queue via CLI::SQS#find_all. With short
+# polling, real (distributed) SQS routinely returns an empty batch while the
+# queue still has messages, so find_all must use long polling and must not stop
+# on the first empty response - otherwise dump/mv silently process only a
+# fraction of the queue.
+#
+# ElasticMQ never produces those false-empties (nor visibility-timeout re-reads),
+# so this drives find_all with scripted clients to verify the behavior
+# deterministically.
+#
+# Lives under spec/integration (not spec/lib) because requiring bin/cli defines
+# Shoryuken::CLI, and Shoryuken#server? is `defined?(Shoryuken::CLI)` - loading
+# it in the unit suite would flip server? for every other spec. Integration
+# specs each run in their own process, so that's contained here.
+
+require 'thor'
+require_relative '../../../bin/cli/base'
+require_relative '../../../bin/cli/sqs'
+
+Msg = Struct.new(:message_id, :receipt_handle)
+
+# A scripted SQS client: hands out pre-canned batches in order (to simulate
+# false-empties and visibility-timeout re-reads), ignoring max_number_of_messages
+# and recording the wait_time_seconds it was asked for.
+class ScriptedSqsClient
+  attr_reader :wait_times
+
+  def initialize(batches)
+    @batches = batches.dup
+    @wait_times = []
+  end
+
+  def receive_message(params)
+    @wait_times << params[:wait_time_seconds]
+    Struct.new(:messages).new(@batches.shift || [])
+  end
+end
+
+# A more realistic client backed by a flat list that honours
+# max_number_of_messages, so the finite-limit / batch-sizing path can be driven.
+class FlatSqsClient
+  def initialize(messages)
+    @messages = messages.dup
+  end
+
+  def receive_message(params)
+    Struct.new(:messages).new(@messages.shift(params[:max_number_of_messages]))
+  end
+end
+
+def find_all_with(client, limit)
+  cli = Shoryuken::CLI::SQS.allocate
+  cli.instance_variable_set(:@_sqs, client)
+
+  collected = []
+  count = cli.send(:find_all, 'http://example.com/q', limit) { |msg| collected << msg }
+  [collected, count]
+end
+
+# --- Drains past a false-empty batch, using long polling -------------------
+client = ScriptedSqsClient.new(
+  [
+    [Msg.new('a'), Msg.new('b'), Msg.new('c')],
+    [Msg.new('d'), Msg.new('e')],
+    [],                       # false-empty while 'f' is still queued
+    [Msg.new('f')]
+  ]
+)
+collected, = find_all_with(client, Float::INFINITY)
+
+assert_equal(%w[a b c d e f], collected.map(&:message_id), 'find_all should drain past a false-empty batch')
+assert(
+  client.wait_times.any? && client.wait_times.all? { |w| w && w.positive? },
+  "find_all should use long polling, saw wait_time_seconds: #{client.wait_times.uniq.inspect}"
+)
+
+# --- Does not re-yield a message that reappears after its visibility timeout ---
+# 'a' is handed back on a later receive (its visibility timeout lapsed before
+# dump/mv deleted it). find_all must yield and count it only once.
+reappearing = ScriptedSqsClient.new(
+  [
+    [Msg.new('a'), Msg.new('b')],
+    [Msg.new('a')],           # re-read of 'a' while it is still in the queue
+    [Msg.new('c')]
+  ]
+)
+collected, count = find_all_with(reappearing, Float::INFINITY)
+
+assert_equal(%w[a b c], collected.map(&:message_id), 'find_all must not re-yield a re-read message')
+assert_equal(3, count, 'find_all count must not double-count a re-read message')
+
+# --- Retains the newest receipt handle for a re-read message ----------------
+# SQS only honors the most recently received receipt handle for deletion, and
+# dump/mv batch_delete after the drain, so the yielded (and later deleted)
+# message must carry the handle from the latest receive, not the first.
+handles = ScriptedSqsClient.new(
+  [
+    [Msg.new('x', 'rh-x-1'), Msg.new('y', 'rh-y')],
+    [Msg.new('x', 'rh-x-2')], # re-read of 'x' with a fresh handle
+    [Msg.new('z', 'rh-z')]
+  ]
+)
+collected, = find_all_with(handles, Float::INFINITY)
+
+x = collected.find { |msg| msg.message_id == 'x' }
+assert_equal('rh-x-2', x.receipt_handle, 'find_all must retain the newest receipt handle for a re-read message')
+assert_equal(%w[x y z], collected.map(&:message_id), 'a re-read must not be yielded twice')
+
+# --- Stops at a finite limit without over-fetching -------------------------
+flat = FlatSqsClient.new((1..25).map { |i| Msg.new("m#{i}") })
+collected, count = find_all_with(flat, 15)
+
+assert_equal(15, count, 'find_all must stop once the limit is reached')
+assert_equal(
+  (1..15).map { |i| "m#{i}" },
+  collected.map(&:message_id),
+  'find_all must yield exactly the first `limit` messages'
+)

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/manager_spec.rb

@@ -48,6 +48,17 @@ RSpec.describe Shoryuken::Manager do
       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|
@@ -222,6 +233,43 @@ RSpec.describe Shoryuken::Manager do
       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

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
@@ -158,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/queue_spec.rb

@@ -187,6 +187,32 @@ RSpec.describe Shoryuken::Queue do
         subject.send_message(message_body: 'original')
       end
     end
+
+    context 'when FIFO' do
+      before { allow(subject).to receive(:fifo?).and_return(true) }
+
+      it 'auto-generates message_group_id and message_deduplication_id by default' do
+        expect(sqs).to receive(:send_message) do |arg|
+          expect(arg[:message_group_id]).to eq described_class::MESSAGE_GROUP_ID
+          expect(arg[:message_deduplication_id]).to be
+        end
+
+        subject.send_message(message_body: 'msg1')
+      end
+
+      context 'and Shoryuken.fifo_message_deduplication is disabled' do
+        before { Shoryuken.fifo_message_deduplication = false }
+
+        it 'does not auto-generate a message_deduplication_id' do
+          expect(sqs).to receive(:send_message) do |arg|
+            expect(arg[:message_group_id]).to eq described_class::MESSAGE_GROUP_ID
+            expect(arg).not_to have_key(:message_deduplication_id)
+          end
+
+          subject.send_message(message_body: 'msg1')
+        end
+      end
+    end
   end
 
   describe '#send_messages' do
@@ -233,6 +259,26 @@ RSpec.describe Shoryuken::Queue do
 
           subject.send_messages([{ message_body: 'msg1', message_attributes: { attr: 'attr1' } }])
         end
+
+        it 'derives the id from the full body, so bodies differing only in an embedded id are not deduplicated' do
+          # Guards the ActiveJob opt-out path: when the adapter omits its own id
+          # (active_job dedup disabled), this fallback still hashes the full body
+          # - which for ActiveJob includes the per-enqueue job_id - so distinct
+          # enqueues get distinct ids and are NOT silently collapsed by SQS.
+          expect(sqs).to receive(:send_message_batch) do |arg|
+            ids = arg[:entries].map { |e| e[:message_deduplication_id] }
+
+            expect(ids).to all(be)
+            expect(ids.uniq.length).to eq(2)
+          end
+
+          subject.send_messages(
+            [
+              { message_body: JSON.dump('job_id' => 'a', 'arguments' => ['same']) },
+              { message_body: JSON.dump('job_id' => 'b', 'arguments' => ['same']) }
+            ]
+          )
+        end
       end
 
       context 'and message_group_id and message_deduplication_id are present' do
@@ -254,6 +300,33 @@ RSpec.describe Shoryuken::Queue do
           )
         end
       end
+
+      context 'and Shoryuken.fifo_message_deduplication is disabled' do
+        before { Shoryuken.fifo_message_deduplication = false }
+
+        it 'does not auto-generate a message_deduplication_id' do
+          expect(sqs).to receive(:send_message_batch) do |arg|
+            first_entry = arg[:entries].first
+
+            expect(first_entry[:message_group_id]).to eq described_class::MESSAGE_GROUP_ID
+            expect(first_entry).not_to have_key(:message_deduplication_id)
+          end
+
+          subject.send_messages([{ message_body: 'msg1', message_attributes: { attr: 'attr1' } }])
+        end
+
+        it 'still honors an explicit message_deduplication_id' do
+          expect(sqs).to receive(:send_message_batch) do |arg|
+            first_entry = arg[:entries].first
+
+            expect(first_entry[:message_deduplication_id]).to eq 'my id'
+          end
+
+          subject.send_messages(
+            [{ message_body: 'msg1', message_attributes: { attr: 'attr1' }, message_deduplication_id: 'my id' }]
+          )
+        end
+      end
     end
 
     it 'accepts an array of string' do
@@ -265,6 +338,19 @@ RSpec.describe Shoryuken::Queue do
 
       subject.send_messages(%w[msg1 msg2])
     end
+
+    context 'when some sends fail' do
+      it 'logs each failure (so bulk/enqueue_all drops are not silent)' do
+        failure = double(id: '1', code: 'code', message: '...', sender_fault: false)
+        logger = double('Logger')
+        allow(sqs).to receive(:send_message_batch).and_return(double(failed: [failure]))
+        allow(subject).to receive(:logger).and_return(logger)
+
+        expect(logger).to receive(:error)
+
+        subject.send_messages(entries: [{ id: '0', message_body: 'msg1' }])
+      end
+    end
   end
 
   describe '#fifo?' do

data/spec/lib/shoryuken/worker/default_executor_spec.rb

@@ -101,5 +101,18 @@ RSpec.describe Shoryuken::Worker::DefaultExecutor do
 
       TestWorker.perform_async('delayed message', queue: new_queue)
     end
+
+    it 'does not mutate the caller-supplied options hash' do
+      allow(sqs_queue).to receive(:send_message)
+
+      options = { queue: queue, message_attributes: { 'custom' => { string_value: 'v', data_type: 'String' } } }
+
+      TestWorker.perform_async('message', options)
+
+      # :queue must not be deleted, :message_body must not be injected, and the
+      # nested message_attributes must not gain shoryuken_class - otherwise a
+      # reused options hash would reroute/corrupt later enqueues.
+      expect(options).to eq(queue: queue, message_attributes: { 'custom' => { string_value: 'v', data_type: 'String' } })
+    end
   end
 end

data/spec/lib/shoryuken/worker/inline_executor_spec.rb

@@ -25,6 +25,18 @@ RSpec.describe Shoryuken::Worker::InlineExecutor do
 
       TestWorker.perform_async('test', message_attributes: custom_attributes)
     end
+
+    it 'does not mutate the caller-supplied options hash' do
+      allow_any_instance_of(TestWorker).to receive(:perform)
+
+      options = { queue: 'a_queue', message_attributes: { 'custom' => { string_value: 'v', data_type: 'String' } } }
+
+      TestWorker.perform_async('test', options)
+
+      # :queue and :message_attributes must survive intact so a reused options
+      # hash routes later jobs correctly instead of falling back to the default.
+      expect(options).to eq(queue: 'a_queue', message_attributes: { 'custom' => { string_value: 'v', data_type: 'String' } })
+    end
   end
 
   describe '.perform_in' do

data/spec/spec_helper.rb

@@ -43,23 +43,23 @@ Dotenv.load
 unless ENV['SIMPLECOV_DISABLED']
   require 'simplecov'
   SimpleCov.start do
-  add_filter '/spec/'
-  add_filter '/test_workers/'
-  add_filter '/examples/'
-  add_filter '/vendor/'
-  add_filter '/.bundle/'
-
-  add_group 'Library', 'lib/'
-  add_group 'ActiveJob', 'lib/active_job'
-  add_group 'Middleware', 'lib/shoryuken/middleware'
-  add_group 'Polling', 'lib/shoryuken/polling'
-  add_group 'Workers', 'lib/shoryuken/worker'
-  add_group 'Helpers', 'lib/shoryuken/helpers'
+  skip '/spec/'
+  skip '/test_workers/'
+  skip '/examples/'
+  skip '/vendor/'
+  skip '/.bundle/'
+
+  group 'Library', 'lib/'
+  group 'ActiveJob', 'lib/active_job'
+  group 'Middleware', 'lib/shoryuken/middleware'
+  group 'Polling', 'lib/shoryuken/polling'
+  group 'Workers', 'lib/shoryuken/worker'
+  group 'Helpers', 'lib/shoryuken/helpers'
 
   enable_coverage :branch
 
   minimum_coverage 89
-  minimum_coverage_by_file 60
+  coverage(:line) { minimum 60, per: :file }
   end
 end
 
@@ -117,6 +117,7 @@ RSpec.configure do |config|
 
     Shoryuken.active_job_queue_name_prefixing = false
     Shoryuken.active_job_fifo_message_deduplication = true
+    Shoryuken.fifo_message_deduplication = true
 
     Shoryuken.worker_registry.clear
     Shoryuken.register_worker('default', TestWorker)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shoryuken
 version: !ruby/object:Gem::Version
-  version: 7.0.3
+  version: 7.0.4
 platform: ruby
 authors:
 - Pablo Cantero
@@ -247,6 +247,7 @@ files:
 - spec/integration/body_parser/json_parser_spec.rb
 - spec/integration/body_parser/proc_parser_spec.rb
 - spec/integration/body_parser/text_parser_spec.rb
+- spec/integration/cli/find_all_spec.rb
 - spec/integration/concurrent_processing/concurrent_processing_spec.rb
 - spec/integration/concurrent_processing/processor_accounting_spec.rb
 - spec/integration/custom_group_polling_strategy/custom_group_polling_strategy_spec.rb
@@ -341,7 +342,13 @@ files:
 homepage: https://github.com/ruby-shoryuken/shoryuken
 licenses:
 - LGPL-3.0
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/ruby-shoryuken/shoryuken
+  source_code_uri: https://github.com/ruby-shoryuken/shoryuken
+  changelog_uri: https://github.com/ruby-shoryuken/shoryuken/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/ruby-shoryuken/shoryuken/issues
+  documentation_uri: https://github.com/ruby-shoryuken/shoryuken
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -356,7 +363,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Shoryuken is a super efficient AWS SQS thread based message processor
 test_files:
@@ -389,6 +396,7 @@ test_files:
 - spec/integration/body_parser/json_parser_spec.rb
 - spec/integration/body_parser/proc_parser_spec.rb
 - spec/integration/body_parser/text_parser_spec.rb
+- spec/integration/cli/find_all_spec.rb
 - spec/integration/concurrent_processing/concurrent_processing_spec.rb
 - spec/integration/concurrent_processing/processor_accounting_spec.rb
 - spec/integration/custom_group_polling_strategy/custom_group_polling_strategy_spec.rb