shoryuken 7.0.1 → 7.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40068ac6b1cebd740c3e9180956731b624a541f967987d0f5f18505ab3885916
-  data.tar.gz: dd58ae5cc228e509665010320bc833c6e8c3377961b7128153406953e3d0c9ed
+  metadata.gz: 988d29701fd4b73dea7d965b283ae8d3fccf5b9737a7e3acdfe5cc760ca82cc5
+  data.tar.gz: b91a7b40cab94ca17fb432433a81323deba9675a3398678c80db1b3a7aa454fb
 SHA512:
-  metadata.gz: 645962569cc872e4709f0b8dcbeac166b7f398459144f088cfab13addcf86f85d494c604591623760c64a126b002b1dcaac64ffda68003ad3c783beff3b02b8a
-  data.tar.gz: adf758d00496d6088d49ed0c456915bcdb18359c9ba80560d97cda1daca526b1233d266a65989851f23cd18887636399aa5836071d12b7b45cb406b241ed3014
+  metadata.gz: e6bc156e3e5387ad74c4a740cae775f6f633b67c26395a3aac11e51b7cc47771785918e5ec457d3f2317148846ef3ad0b137b5f6e012f3f75aec6536a2eb2deb
+  data.tar.gz: 87f0feeae55309458dbd5eab9fea4fbdb83a5689bd526b0e22857cb89f0af7027346f2e1487614965b3208aafaf6167dc7bb2573e160d45cfb54e8133baa09c0

data/.github/workflows/push.yml

@@ -19,12 +19,12 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
         with:
           fetch-depth: 0
 
       - name: Set up Ruby
-        uses: ruby/setup-ruby@8d27f39a5e7ad39aebbcbd1324f7af020229645c # v1.287.0
+        uses: ruby/setup-ruby@d45b1a4e94b71acab930e56e79c6aa188764e7f9 # v1.316.0
         with:
           bundler-cache: false
 
@@ -33,4 +33,4 @@ jobs:
           bundle install --jobs 4 --retry 3
 
       # Release
-      - uses: rubygems/release-gem@1c162a739e8b4cb21a676e97b087e8268d8fc40b # v1.1.2
+      - uses: rubygems/release-gem@052cc82692552de3ef2b81fd670e41d13cba8092 # v1.4.0

data/.github/workflows/specs.yml

@@ -11,17 +11,41 @@ jobs:
       matrix:
         ruby: ['3.2', '3.3', '3.4', '4.0']
     runs-on: ubuntu-latest
+    # Unit specs finish in under a minute; fail fast instead of letting a
+    # wedged runner occupy the job slot for the 6-hour default
+    timeout-minutes: 10
     steps:
       - name: Checkout code
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
 
-      - uses: ruby/setup-ruby@8d27f39a5e7ad39aebbcbd1324f7af020229645c # v1.287.0
+      - uses: ruby/setup-ruby@d45b1a4e94b71acab930e56e79c6aa188764e7f9 # v1.316.0
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
 
       - name: Run specs
-        run: bundle exec rake spec
+        run: |
+          # Run rspec directly (not via rake) so $SPEC_PID is the ruby process
+          # itself — the USR1 watchdog below sends the signal to that pid, and
+          # spec_helper registers a USR1 handler that prints a thread dump.
+          # Running via 'bundle exec rake spec' would send the signal to rake,
+          # which has no USR1 handler and would crash before the dump appears.
+          bundle exec rspec --format documentation &
+          SPEC_PID=$!
+          # Send USR1 after 8 minutes so the thread-dump handler in spec_helper
+          # prints a backtrace before the 10-minute job timeout kills everything.
+          ( sleep 480
+            if kill -0 $SPEC_PID 2>/dev/null; then
+              echo "=== specs still running after 8 minutes — requesting thread dump ==="
+              kill -USR1 $SPEC_PID 2>/dev/null || true
+              sleep 5
+            fi
+          ) &
+          WATCHDOG_PID=$!
+          wait $SPEC_PID
+          EXIT_CODE=$?
+          kill $WATCHDOG_PID 2>/dev/null || true
+          exit $EXIT_CODE
 
   integrations:
     name: Integrations
@@ -29,23 +53,25 @@ jobs:
       matrix:
         ruby: ['3.2', '3.3', '3.4', '4.0']
     runs-on: ubuntu-latest
+    # Integration specs normally take ~4 minutes
+    timeout-minutes: 15
     steps:
       - name: Checkout code
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
 
-      - name: Start LocalStack
+      - name: Start ElasticMQ
         run: docker compose up -d
 
-      - name: Wait for LocalStack
+      - name: Wait for ElasticMQ
         run: |
           timeout 30s bash -c '
-          until curl -s http://localhost:4566/_localstack/health | grep -q "\"sqs\": \"available\""; do
-            echo "Waiting for LocalStack..."
-            sleep 2
+          until curl -s http://localhost:9324/health; do
+            echo "Waiting for ElasticMQ..."
+            sleep 1
           done
           '
 
-      - uses: ruby/setup-ruby@8d27f39a5e7ad39aebbcbd1324f7af020229645c # v1.287.0
+      - uses: ruby/setup-ruby@d45b1a4e94b71acab930e56e79c6aa188764e7f9 # v1.316.0
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
@@ -56,6 +82,7 @@ jobs:
   ci-success:
     name: CI Success
     runs-on: ubuntu-latest
+    timeout-minutes: 5
     if: always()
     needs:
       - specs

data/.github/workflows/verify-action-pins.yml

@@ -7,7 +7,7 @@ jobs:
   verify:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
       - name: Check SHA pins
         run: |
           if grep -E -r "uses: .*/.*@(v[0-9]+|main|master)($|[[:space:]]|$)" --include="*.yml" --include="*.yaml" .github/workflows/ | grep -v "#"; then

data/.gitignore

@@ -26,7 +26,6 @@ shoryuken.yml
 .env
 rubocop.html
 .byebug_history
-.localstack
 spec/integration/**/Gemfile.lock
 spec/integration/**/vendor/
 spec/integration/**/.bundle/

data/.ruby-version

@@ -1 +1 @@
-4.0.1
+4.0.5

data/CHANGELOG.md

@@ -1,3 +1,123 @@
+## [Unreleased]
+
+## [7.0.3] - 2026-07-10
+
+- Feature: `Shoryuken.active_job_fifo_message_deduplication` to opt out of FIFO dedup id generation (mensfeld)
+  - For FIFO queues the ActiveJob adapter derives a content-based `message_deduplication_id` from the
+    serialized job minus `job_id`/`enqueued_at` (#457 / #750), so two distinct enqueues of the same job
+    class and arguments within SQS's 5-minute window silently collapse into one - a "skipped message" trap
+  - Set `Shoryuken.active_job_fifo_message_deduplication = false` to stop generating that id, so identical
+    jobs are no longer silently dropped (rely on the queue's content-based deduplication or explicit ids)
+  - Defaults to `true`, preserving the existing behavior; an explicit `message_deduplication_id` is still honored
+
+- Fix: Polling strategies are now thread-safe, and WeightedRoundRobin unpauses processed queues reliably (mensfeld)
+  - `message_processed` runs on processor-completion threads (for FIFO queues) while `next_queue`/`messages_found`
+    run on the dispatch thread; they mutate the same state with no synchronization, which is benign on MRI (GVL)
+    but corrupts state on JRuby/TruffleRuby. Both `WeightedRoundRobin` and `StrictPriority` now serialize access
+    with a mutex
+  - `WeightedRoundRobin#unpause_queues` only checked the head of the paused list, so a queue marked ready by
+    `message_processed` could stay stuck behind an earlier-paused queue; it now unpauses the first expired entry
+    anywhere in the list
+
+- Fix: `TimerTask#kill` no longer deadlocks on Ruby 3.2 under concurrent callers (mensfeld)
+  - `kill` called `@thread.kill` while holding `@mutex`; the timer loop's `ensure` block calls
+    `@mutex.synchronize` to clear `@running`, so on Ruby 3.2 (where `Thread#kill` yields the GVL
+    to the killed thread for cleanup before returning) both threads waited on each other forever
+  - The thread is now killed after the mutex is released, so the ensure block can always acquire it
+
+- Fix: Stopping the launcher no longer destroys the process-global IO executor (mensfeld)
+  - With no `launcher_executor` configured, `Launcher#executor` fell back to `Concurrent.global_io_executor`,
+    and `Launcher#stop`/`#stop!` call `shutdown` (and `kill`) on it
+  - Shutting down that process-wide pool broke anything else relying on concurrent-ruby's `:io` pool
+    (including Shoryuken's own `ShoryukenConcurrentSendAdapter`) and prevented starting a fresh launcher
+    in the same process
+  - The launcher now owns a dedicated `Concurrent::CachedThreadPool`, so stopping it leaves the global
+    IO executor untouched
+
+- Fix: `Queue#delete_messages` now logs every batch-delete failure and returns a robust boolean (mensfeld)
+  - It used `failed.any? { |f| logger.error ... }`, which short-circuited after the first failure - so when
+    a batch had multiple failures only the first was logged - and only returned truthy because `Logger#error`
+    happens to return true (a custom logger returning falsey would have hidden the failure from callers)
+  - It now logs each failure and returns `failed.any?`, so `NonRetryableException`/`AutoDelete` reliably see
+    that some messages may remain and need reprocessing
+
+- Fix: Lifecycle events fired in reverse no longer alternate handler order (mensfeld)
+  - `Util#fire_event` reversed the stored handler array in place with `reverse!`, so an event fired more
+    than once with `reverse: true` (e.g. `:shutdown` via `stop` then `stop!`) flipped order each time
+  - It now reverses a copy, leaving the stored handler order untouched
+
+- Fix: A fatal dispatch error no longer hard-kills an embedded host process (mensfeld)
+  - `Manager#handle_dispatch_error` sent `Process.kill('USR1', Process.pid)` unconditionally after a
+    dispatch error (e.g. SQS still failing once the fetcher exhausted its retries)
+  - The CLI Runner traps USR1 and turns it into a graceful shutdown, but a host embedding
+    `Shoryuken::Launcher` directly has USR1's default disposition, so the whole process - and its
+    in-flight workers - was terminated
+  - When embedded (no CLI Runner), the failing manager now just stops itself and `Launcher#healthy?`
+    reports the failure; the USR1 signal is only sent in server (CLI) mode, preserving the
+    supervisor-restart behavior there
+
+- Fix: Graceful stop is now bounded by the configured timeout (mensfeld)
+  - `Launcher#stop` (the soft shutdown behind USR1/TSTP) called `executor.wait_for_termination` with no
+    argument - an unbounded wait - so a single hung worker blocked shutdown forever
+  - Both `Launcher#stop` and `Launcher#stop!` now share a `shutdown_executor` helper that waits up to
+    `Shoryuken.options[:timeout]` seconds for in-flight workers, then force-kills the executor so the
+    process can exit; the graceful stop still waits for workers, just no longer indefinitely
+
+- Docs: Correct the `retry_intervals` exponential backoff documentation (mensfeld)
+  - The `exponential_backoff?` docstring claimed retries stop ("before giving up") after the last configured
+    interval. They do not: once the intervals are exhausted, the last interval is reused for every later
+    attempt, and SQS's redrive policy (maxReceiveCount) is what ultimately moves a message to a dead-letter queue
+  - Added a spec pinning that far-later attempts keep reusing the last interval
+
+- Fix: `CurrentAttributes.persist` no longer drops a class when called once per class (mensfeld)
+  - The storage key was derived from the per-call index, so registering classes across separate `persist`
+    calls made the third call reuse `cattr_0` and silently overwrite the second class - its attributes were
+    then never serialized or restored
+  - The key now uses the running registry size, so incremental and single-call registration both yield
+    distinct, stable keys (single-call `persist(A, B, C)` keys are unchanged)
+
+- Fix: Busy-processor accounting no longer breaks when processor completion raises (mensfeld)
+  - `Manager#assign` chained `.then { processor_done }.rescue { processor_done }`, so an exception inside
+    `processor_done` (SQS lookups or a polling strategy's `message_processed` callback) ran completion twice
+  - The busy counter was decremented twice for one message and drifted negative, inflating `ready` and
+    silently breaking the configured concurrency limit for the life of the process
+  - Completion now runs in an `ensure` around processing (exactly once), and `processor_done` logs
+    instead of leaking exceptions from the FIFO bookkeeping
+
+- Fix: Repeated graceful stop no longer deadlocks the process (mensfeld)
+  - `Manager#await_dispatching_in_progress` popped a signal queue that received exactly one token,
+    so a second `Launcher#stop` blocked forever on an empty queue
+  - Operationally this was the TSTP -> USR1 sequence: both signals trigger a graceful stop, leaving
+    the process stuck in the signal loop where even TERM/INT were no longer handled (only SIGKILL worked)
+  - The dispatch loop now closes the signal queue instead of pushing a token, releasing every pending
+    and future waiter; the dispatch chain also releases waiters if the executor rejects a post during
+    a racing hard shutdown
+
+- Fix: `non_retryable_exceptions` is no longer ignored when `retry_intervals` is also configured (mensfeld)
+  - `ExponentialBackoffRetry` swallowed every exception after scheduling a retry, so `NonRetryableException`
+    (which sits outside it in the default middleware chain) never saw non-retryable errors - poison messages
+    were retried indefinitely (with the last interval repeated) instead of being deleted immediately
+  - `ExponentialBackoffRetry` now re-raises exceptions classified as non-retryable so the message gets deleted
+  - Exception classification is extracted to `NonRetryableException.non_retryable?` and shared by both middlewares
+
+- Enhancement: Use dynamic Ruby warning category opt-in in test helpers (mensfeld)
+  - Replace version-gated `Warning[:performance]` with `Warning.categories`-based auto-enablement
+  - Automatically enables all non-deprecated, non-experimental warning categories for forward compatibility
+  - Applied to both `spec/spec_helper.rb` and `spec/integrations_helper.rb`
+
+## [7.0.2] - 2026-04-16
+
+- Enhancement: Replace LocalStack with ElasticMQ for SQS integration tests (mensfeld)
+  - ElasticMQ is free, open-source, and requires no auth token (LocalStack 2026.x requires paid account)
+  - Uses `softwaremill/elasticmq-native` image (~30MB vs ~1GB+, starts in milliseconds)
+  - Rename `setup_localstack` to `setup_sqs` and `bin/clean_localstack` to `bin/clean_sqs`
+
+- Fix: Allow custom polling strategy to be configured per-group via `add_group` (mensfeld)
+  - `add_group` now accepts `polling_strategy:` keyword argument
+  - `polling_strategy()` reads from the groups hash populated by `add_group`, with fallback to raw options
+  - `EnvironmentLoader` passes `polling_strategy` through when parsing YAML group config
+  - [#925](https://github.com/ruby-shoryuken/shoryuken/issues/925)
+
 ## [7.0.1] - 2026-02-07
 
 - Enhancement: Add non-retryable exception middleware (Saidbek)

data/README.md

@@ -63,7 +63,7 @@ To run all unit specs against the latest dependency versions, execute
 bundle exec rake spec
 ```
 
-To run integration specs (including Rails tests), start LocalStack and run:
+To run integration specs (including Rails tests), start ElasticMQ and run:
 
 ```sh
 docker compose up -d

data/bin/{clean_localstack → clean_sqs}

@@ -1,14 +1,14 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Removes all integration test SQS queues from LocalStack
+# Removes all integration test SQS queues from ElasticMQ
 #
-# Useful when having a long-running LocalStack instance that cannot be fully
+# Useful when having a long-running ElasticMQ instance that cannot be fully
 # restarted between test runs. All integration test queues use the 'it-' prefix,
 # making them easy to identify and remove.
 #
 # Usage:
-#   bin/clean_localstack
+#   bin/clean_sqs
 
 require 'aws-sdk-sqs'
 
@@ -16,7 +16,7 @@ THREADS_COUNT = 3
 
 sqs = Aws::SQS::Client.new(
   region: 'us-east-1',
-  endpoint: 'http://localhost:4566',
+  endpoint: 'http://localhost:9324',
   access_key_id: 'fake',
   secret_access_key: 'fake'
 )

data/bin/cli/sqs.rb

@@ -146,6 +146,13 @@ module Shoryuken
                            value[:string_value].bytesize
                          elsif value[:binary_value]
                            value[:binary_value].bytesize
+                         else
+                           # List-type attributes (string_list_values /
+                           # binary_list_values) carry no scalar value here and
+                           # are intentionally not requeued (see
+                           # normalize_dump_message). Size them as 0 rather than
+                           # crashing the whole batch with `nil + Integer`.
+                           0
                          end
             name_size + data_type_size + value_size
           end

data/bin/integrations

@@ -70,21 +70,23 @@ class IntegrationRunner
   def run_specs(specs)
     results = []
 
-    specs.each do |spec|
+    specs.each_with_index do |spec, idx|
+      prefix = "[#{idx + 1}/#{specs.size}]"
+      puts "#{prefix} RUNNING  #{spec[:name]}"
+      $stdout.flush
+
       result = run_spec(spec)
       results << result
 
-      if result[:skipped]
-        print 'S'
-      elsif result[:success]
-        print '.'
-      else
-        print 'F'
-      end
+      elapsed = result[:duration] ? format('%.1fs', result[:duration]) : '?'
+      status  = if result[:skipped] then 'SKIPPED'
+                elsif result[:success] then 'OK     '
+                else                       'FAILED '
+                end
+      puts "#{prefix} #{status} #{spec[:name]} (#{elapsed})"
       $stdout.flush
     end
 
-    puts
     results
   end
 
@@ -132,34 +134,50 @@ class IntegrationRunner
     output = []
     start_time = Time.now
 
-    begin
-      Timeout.timeout(TIMEOUT) do
-        # Use unbundled env to prevent pollution from previous test runs
-        # This is especially important after Rails integration tests that use
-        # bundle install --standalone with different gem versions
-        Bundler.with_unbundled_env do
-          IO.popen(env, cmd, chdir: spec[:directory], err: [:child, :out]) do |io|
-            io.each_line { |line| output << line }
-          end
+    Bundler.with_unbundled_env do
+      # Use non-block popen so we control when waitpid runs.  The block form
+      # calls io.close (which calls waitpid internally) as part of its own
+      # ensure, so if the child is still running when Timeout::Error fires,
+      # io.close blocks indefinitely before we can rescue the error.
+      io = IO.popen(env, cmd, chdir: spec[:directory], err: [:child, :out])
+      timed_out = false
+
+      begin
+        Timeout.timeout(TIMEOUT) do
+          io.each_line { |line| output << line }
+        end
+      rescue Timeout::Error
+        timed_out = true
+      ensure
+        # Kill before closing: io.close calls waitpid, which blocks if the
+        # child is still alive.  Sending SIGKILL first guarantees the child
+        # exits promptly so waitpid (inside io.close) returns immediately.
+        begin
+          Process.kill('KILL', io.pid)
+        rescue Errno::ESRCH
+          # Child already exited on its own — nothing to kill
         end
+        io.close rescue nil
       end
 
-      {
-        spec: spec,
-        success: $?.success?,
-        exit_code: $?.exitstatus,
-        duration: Time.now - start_time,
-        output: output.join
-      }
-    rescue Timeout::Error
-      {
-        spec: spec,
-        success: false,
-        exit_code: -1,
-        error: 'Timeout',
-        duration: Time.now - start_time,
-        output: output.join
-      }
+      if timed_out
+        {
+          spec: spec,
+          success: false,
+          exit_code: -1,
+          error: 'Timeout',
+          duration: Time.now - start_time,
+          output: output.join
+        }
+      else
+        {
+          spec: spec,
+          success: $?.success?,
+          exit_code: $?.exitstatus,
+          duration: Time.now - start_time,
+          output: output.join
+        }
+      end
     end
   end
 

data/docker-compose.yml

@@ -1,22 +1,6 @@
 services:
-  localstack:
-    image: localstack/localstack:latest
-    container_name: localstack
+  elasticmq:
+    image: softwaremill/elasticmq-native:1.7.1
+    container_name: elasticmq
     ports:
-      - "4566:4566"
-      - "4510-4559:4510-4559"
-    environment:
-      - SERVICES=sqs
-      - DEBUG=${DEBUG:-0}
-      - DOCKER_HOST=unix:///var/run/docker.sock
-      - AWS_DEFAULT_REGION=us-east-1
-      - AWS_ACCESS_KEY_ID=test
-      - AWS_SECRET_ACCESS_KEY=test
-    volumes:
-      - "${LOCALSTACK_VOLUME_DIR:-./.localstack}:/var/lib/localstack"
-      - "/var/run/docker.sock:/var/run/docker.sock"
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:4566/_localstack/health"]
-      interval: 5s
-      timeout: 10s
-      retries: 5
+      - "9324:9324"

data/lib/active_job/queue_adapters/shoryuken_adapter.rb

@@ -177,9 +177,11 @@ module ActiveJob
           message_attributes: attributes.merge(MESSAGE_ATTRIBUTES)
         }
 
-        if queue.fifo?
+        if queue.fifo? && Shoryuken.active_job_fifo_message_deduplication?
           # See https://github.com/ruby-shoryuken/shoryuken/issues/457 and
           # https://github.com/ruby-shoryuken/shoryuken/pull/750#issuecomment-1781317929
+          # Disable via Shoryuken.active_job_fifo_message_deduplication = false when distinct
+          # enqueues of the same job class and arguments must not be silently deduplicated.
           msg[:message_deduplication_id] = Digest::SHA256.hexdigest(
             JSON.dump(body.except('job_id', 'enqueued_at'))
           )

data/lib/shoryuken/active_job/current_attributes.rb

@@ -11,7 +11,12 @@ module Shoryuken
     # This ensures that request-scoped context (like current user, tenant, locale)
     # automatically flows from the code that enqueues a job to the job's execution.
     #
-    # Based on Sidekiq's approach to persisting current attributes.
+    # Based on Sidekiq's approach to persisting current attributes, with one
+    # deliberate difference in cleanup: Sidekiq only touches the classes carried
+    # by a job and leaves the general reset to the Rails executor it runs jobs
+    # inside. Shoryuken does not run jobs inside that executor by default, so the
+    # loader resets every registered class after each job itself - see the note
+    # on {Loading#perform}.
     #
     # @example Setup in initializer
     #   require 'shoryuken/active_job/current_attributes'
@@ -58,8 +63,12 @@ module Shoryuken
         def persist(*klasses)
           @cattrs ||= {}
 
-          klasses.flatten.each_with_index do |klass, idx|
-            key = @cattrs.empty? ? 'cattr' : "cattr_#{idx}"
+          klasses.flatten.each do |klass|
+            # Key off the running registry size, not the per-call index, so that
+            # registering classes across separate persist calls still produces
+            # distinct keys (a per-call index restarts at 0 each call and would
+            # overwrite earlier registrations).
+            key = @cattrs.empty? ? 'cattr' : "cattr_#{@cattrs.size}"
             @cattrs[key] = klass.to_s
           end
 
@@ -109,13 +118,10 @@ module Shoryuken
         # @param hash [Hash] the deserialized job data
         # @return [void]
         def perform(sqs_msg, hash)
-          klasses_to_reset = []
-
           CurrentAttributes.cattrs&.each do |key, klass_name|
             next unless hash.key?(key)
 
             klass = klass_name.constantize
-            klasses_to_reset << klass
 
             begin
               attrs = Serializer.deserialize(hash[key])
@@ -131,7 +137,29 @@ module Shoryuken
 
           super
         ensure
-          klasses_to_reset.each(&:reset)
+          # Reset every registered CurrentAttributes class after the job - not
+          # only the ones whose key was in this message.
+          #
+          # Why unconditional (and why this differs from Sidekiq): Sidekiq's
+          # loader only touches classes present in the job and relies on the
+          # Rails executor - which it runs every job inside - to reset all
+          # CurrentAttributes between units of work. Shoryuken has no such safety
+          # net: it wraps a job in the reloader/executor only when
+          # `enable_reloading` is set, which is off by default, so nothing else
+          # clears CurrentAttributes between jobs.
+          #
+          # A blanket reset here is therefore the only thing guaranteeing a clean
+          # thread. Resetting only the present keys leaks whenever a value ends up
+          # set during a job whose message carried no cattr key - e.g. the worker
+          # (or code it calls) writes to Current, on a keyless message (empty
+          # context at enqueue, a different producer, or persist configured after
+          # the message was queued). CurrentAttributes are thread-local and the
+          # pool reuses threads, so that value would surface in the next job.
+          CurrentAttributes.cattrs&.each_value do |klass_name|
+            klass_name.constantize.reset
+          rescue => e
+            Shoryuken.logger.warn("Failed to reset CurrentAttributes #{klass_name}: #{e.message}")
+          end
         end
       end
     end

data/lib/shoryuken/environment_loader.rb

@@ -200,7 +200,7 @@ module Shoryuken
       end
 
       Shoryuken.options[:groups].to_a.each do |group, options|
-        Shoryuken.add_group(group, options[:concurrency], delay: options[:delay])
+        Shoryuken.add_group(group, options[:concurrency], delay: options[:delay], polling_strategy: options[:polling_strategy])
 
         options[:queues].to_a.each do |queue, weight|
           parse_queue(queue, weight, group)

data/lib/shoryuken/fetcher.rb

@@ -72,12 +72,18 @@ module Shoryuken
 
       shoryuken_queue = Shoryuken::Client.queues(queue.name)
 
-      options[:max_number_of_messages]  = max_number_of_messages(shoryuken_queue, limit, options)
       options[:message_attribute_names] = %w[All]
       options[:attribute_names]         = %w[All]
 
+      # Merge per-queue options BEFORE computing the cap so the FIFO
+      # one-at-a-time guard (and FETCH_LIMIT) always win. Computing the cap last
+      # means a queue option of max_number_of_messages can only lower the count,
+      # never raise a non-batch FIFO queue above 1 - which would let SQS return
+      # several messages from the same group and break ordering.
       options.merge!(queue.options)
 
+      options[:max_number_of_messages] = max_number_of_messages(shoryuken_queue, limit, options)
+
       shoryuken_queue.receive_messages(options)
     end
 

data/lib/shoryuken/helpers/timer_task.rb

@@ -42,14 +42,21 @@ module Shoryuken
       #
       # @return [Boolean] true if killed, false if already killed
       def kill
+        thread_to_kill = nil
+
         @mutex.synchronize do
           return false if @killed
 
           @killed = true
           @running = false
-
-          @thread.kill if @thread&.alive?
+          thread_to_kill = @thread
         end
+
+        # Kill the thread AFTER releasing the mutex. The timer loop's ensure
+        # block calls @mutex.synchronize to clear @running; killing the thread
+        # while holding that mutex deadlocks on Ruby 3.2, where Thread#kill
+        # yields the GVL to the killed thread for cleanup before returning.
+        thread_to_kill&.kill if thread_to_kill&.alive?
         true
       end
 
@@ -59,6 +66,16 @@ module Shoryuken
       #
       # @return [void]
       def run_timer_loop
+        # The timer thread inherits the priority of the thread that called
+        # #execute. Shoryuken runs workers at a lowered priority
+        # (Shoryuken.thread_priority, default -1) and starts the
+        # auto-visibility-extension timer from inside that worker thread, so the
+        # timer would otherwise inherit -1. A latency-sensitive timer must not
+        # run below normal priority: under CPU contention a delayed extension can
+        # miss the visibility timeout and let the message be redelivered (double
+        # processed). Reset to normal priority.
+        Thread.current.priority = 0
+
         until @killed
           sleep(@execution_interval)
           break if @killed