shoryuken 7.0.2 → 7.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63763ea11f3377475150b2270c7162fa5cb9a35e39cdd2a534e353837dc3e6ff
-  data.tar.gz: f265d74ebdb8a087cb658a8f442489523305e7cd551e5fae4ae16f9709f238ae
+  metadata.gz: b332f880ab52b8380e13758f98bbca5d35a5a21f693753d536564c2dc760eadb
+  data.tar.gz: 9660f222a93c1fc517cc7f65bf029ee6c31e9a6b5526d67af917a91e64768ca4
 SHA512:
-  metadata.gz: 012a20c2c6cf74c8af2be01f046e137f74df8f6ca0746bc3c05f3dfc6eb45d0bf320a4a6493917c8c12371f94dafb0777873eb71d4298f097ecdb1bf9f9b2fd5
-  data.tar.gz: e257ec56be80a862449937cf882fd2dfb42037c4b9e1bbfe2987463a45e7bd0857a18a94bafd225ecb3e170180a62d59b4e3cd926d863246621d6c5683bce9a1
+  metadata.gz: ce8200034dfe12e010bbb928f73d7ae35f2abfda4d85235cc7af189d26306d254bfd84e6956dace838ba0a222768628cf2c4785f657f8c23cd07ddc47219064a
+  data.tar.gz: c7a947da8aa8dadd9f79bedd89d02a67cfd715e715294d5e38a396cbb7070e5a06b4aa4055e347493eaa9373242593a5eacaed27ebb7528f16b21d8007a44825

data/.github/workflows/push.yml

@@ -19,12 +19,12 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
         with:
           fetch-depth: 0
 
       - name: Set up Ruby
-        uses: ruby/setup-ruby@e65c17d16e57e481586a6a5a0282698790062f92 # v1.300.0
+        uses: ruby/setup-ruby@a0102e0972be65f351c307e2d64b9314a57c8073 # v1.324.0
         with:
           bundler-cache: false
 
@@ -33,4 +33,4 @@ jobs:
           bundle install --jobs 4 --retry 3
 
       # Release
-      - uses: rubygems/release-gem@6317d8d1f7e28c24d28f6eff169ea854948bd9f7 # v1.2.0
+      - uses: rubygems/release-gem@7f9650160c1a4e7989fdc9855807bdbd421d8b6b # v1.4.1

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@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
 
-      - uses: ruby/setup-ruby@e65c17d16e57e481586a6a5a0282698790062f92 # v1.300.0
+      - uses: ruby/setup-ruby@a0102e0972be65f351c307e2d64b9314a57c8073 # v1.324.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,9 +53,11 @@ 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@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
 
       - name: Start ElasticMQ
         run: docker compose up -d
@@ -45,7 +71,7 @@ jobs:
           done
           '
 
-      - uses: ruby/setup-ruby@e65c17d16e57e481586a6a5a0282698790062f92 # v1.300.0
+      - uses: ruby/setup-ruby@a0102e0972be65f351c307e2d64b9314a57c8073 # v1.324.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@3d3c42e5aac5ba805825da76410c181273ba90b1 # 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/.ruby-version

@@ -1 +1 @@
-4.0.2
+4.0.7

data/.yard-lint.yml

@@ -66,6 +66,34 @@ Documentation/BlankLineBeforeDefinition:
     SingleBlankLine: true
     OrphanedDocs: true
 
+Documentation/DuplicateNamespaceComment:
+  Description: Detects namespaces documented with a YARD comment in more than one file.
+  Enabled: true
+  Severity: error
+
+Documentation/UnderfilledLines:
+  Description: Detects documentation prose that wraps too early and wastes horizontal space.
+  Enabled: true
+  Severity: error
+  # Aligned with RuboCop's Layout/LineLength so documentation prose wraps to the same
+  # width as code.
+  MaxLength: 125
+
+Documentation/LineLength:
+  Description: Detects documentation lines that exceed the maximum length.
+  Enabled: true
+  Severity: error
+  # Aligned with RuboCop's Layout/LineLength.
+  MaxLength: 125
+
+Documentation/TextSubstitution:
+  Description: Detects em/en-dashes in documentation and replaces them with hyphens.
+  Enabled: true
+  Severity: error
+  Substitutions:
+    "—": "-"    # em-dash (U+2014)
+    "–": "-"    # en-dash (U+2013)
+
 # Tags validators
 Tags/Order:
   Description: Enforces consistent ordering of YARD tags.
@@ -146,7 +174,7 @@ Tags/OptionTags:
 Tags/ExampleSyntax:
   Description: Validates Ruby syntax in @example tags.
   Enabled: true
-  Severity: warning
+  Severity: error
 
 Tags/RedundantParamDescription:
   Description: Detects meaningless parameter descriptions that add no value.

data/CHANGELOG.md

@@ -1,3 +1,174 @@
+## [7.0.4] - 2026-09-23
+
+- Fix: `shoryuken sqs dump`/`mv` no longer stop early on real SQS (mensfeld)
+  - `find_all` used short polling and broke on the first empty `receive_message` response. Real
+    (distributed) SQS routinely returns an empty batch while the queue still has messages, so dump/mv
+    quietly processed only a fraction of the queue (invisible on single-node ElasticMQ/LocalStack)
+  - It now long-polls and only stops after several consecutive empty batches, so the queue is actually drained
+  - Because a longer drain can outlast the queue's visibility timeout (dump/mv delete only after `find_all`
+    returns), re-read messages are now deduplicated by message id, so they are not dumped/moved or counted
+    twice, and the newest receipt handle is kept so the deferred delete still succeeds
+  - Deletion stays deferred (a failed dump/mv deletes nothing), so a queue larger than SQS's in-flight limit
+    (~120k standard / ~20k FIFO) drains over multiple runs rather than one - no message is lost
+
+- Fix: Graceful stop no longer deadlocks when a manager's dispatch loop never started (mensfeld)
+  - `await_dispatching_in_progress` blocks on a `Queue` that is only closed from inside `dispatch_loop` when it
+    observes the stop flag. If the loop never runs - a graceful stop arriving before the start `Future` is
+    scheduled, or an embedded host whose executor pool is saturated so `manager.start` never runs - the signal
+    was never closed and `Launcher#stop` deadlocked
+  - `stop_new_dispatching` now closes the release signal itself when the loop hasn't started (tracked via a new
+    flag); `Queue#close` is idempotent, so a loop that does start later and closes it again is harmless
+
+- Feature: `Shoryuken.fifo_message_deduplication` to opt out of content-based dedup id generation for raw sends (mensfeld)
+  - `Queue#add_fifo_attributes!` always set `message_deduplication_id` to a SHA256 of the body when none was
+    given, so two raw sends of an identical body within SQS's 5-minute window (`Worker.perform_async`,
+    `Queue#send_message`/`#send_messages`) were silently deduplicated - the second dropped. ActiveJob got an
+    opt-out in #1017 but the raw path had none
+  - Set `Shoryuken.fifo_message_deduplication = false` to stop auto-generating that id, so identical bodies are
+    no longer silently dropped (provide a `message_deduplication_id` yourself or enable
+    `ContentBasedDeduplication` on the queue)
+  - Defaults to `true`, preserving the existing behavior; an explicit `message_deduplication_id` is still honored
+
+- Fix: Harden `ExponentialBackoffRetry` visibility handling (mensfeld)
+  - `next_visibility_timeout` could return a negative value when a job ran past the 12h SQS ceiling (its
+    `max_timeout` goes below zero), and `change_message_visibility` rejects a negative timeout; it now clamps
+    to 0 so the message is retried as soon as possible
+  - `handle_failure` called `change_visibility` unguarded, so a failure there (e.g. an expired receipt handle)
+    escaped the `rescue` in `#call` and masked the original worker error from exception handlers/notifiers; it
+    now rescues, logs, and reports "not retried" so the original error is re-raised and the message falls back
+    to the queue's default visibility timeout
+  - The failure `rescue` in `#call` is now scoped to the single-message `yield` only, so a batch worker's error
+    no longer routes the message Array into `handle_failure` (raising a `NoMethodError` that masked the original)
+
+- Fix: `perform_async` no longer mutates the caller-supplied options hash (mensfeld)
+  - `DefaultExecutor#perform_async` and `InlineExecutor#perform_async` deleted `:queue`, injected
+    `:message_body`, and wrote `shoryuken_class` into the nested `:message_attributes` in place, so a caller
+    reusing one options hash across enqueues had `:queue` stripped after the first call - silently routing later
+    jobs to the worker's default queue
+  - Both now operate on a `dup` and rebuild `:message_attributes` with `merge`, leaving the caller's hash untouched
+
+- Fix: `Shoryuken::Client.queues` no longer builds the same queue more than once under concurrency (mensfeld)
+  - The cache used an unsynchronized `@@queues[name] ||= Shoryuken::Queue.new(...)`. Building a queue makes
+    SQS API calls, and that I/O releases the GVL, so concurrent first-access (dispatch, processor-completion
+    and worker threads all call it) built the queue multiple times - redundant API calls, and a corrupt cache
+    on JRuby/TruffleRuby
+  - Access to the cache is now guarded by a mutex
+
+- Fix: Busy-processor counter no longer leaks when the executor rejects a worker post (mensfeld)
+  - `Manager#assign` increments `@busy_processors` before posting the worker `Concurrent::Promise`, but the
+    matching decrement (`processor_done`) runs inside the promise body. When the post is rejected with
+    `Concurrent::RejectedExecutionError` - a hard stop racing the `running?` check, or a saturated bounded custom
+    `launcher_executor` - the body never runs and the counter leaks
+  - With a bounded executor the leak is permanent: `ready` (`@max_processors - busy`) keeps shrinking until
+    dispatch stalls and the group silently stops processing
+  - The increment is now rolled back on `RejectedExecutionError` by decrementing directly (the message was never
+    processed, so the FIFO `message_processed` callback must not run) (#1029)
+
+## [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)

data/Gemfile.lint.lock

@@ -31,11 +31,11 @@ GEM
     unicode-display_width (3.2.0)
       unicode-emoji (~> 4.1)
     unicode-emoji (4.2.0)
-    yard (0.9.38)
-    yard-lint (1.4.0)
+    yard (0.9.45)
+    yard-lint (1.10.2)
       yard (~> 0.9)
       zeitwerk (~> 2.6)
-    zeitwerk (2.7.4)
+    zeitwerk (2.8.2)
 
 PLATFORMS
   ruby
@@ -47,6 +47,7 @@ DEPENDENCIES
 
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
+  bundler (4.0.17) sha256=214e21431b5665dd2f99df8a5511c6b151d7a72e8015c8b38f8b775b61cbb6c1
   json (2.18.0) sha256=b10506aee4183f5cf49e0efc48073d7b75843ce3782c68dbeb763351c08fd505
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87
@@ -61,9 +62,9 @@ CHECKSUMS
   ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33
   unicode-display_width (3.2.0) sha256=0cdd96b5681a5949cdbc2c55e7b420facae74c4aaf9a9815eee1087cb1853c42
   unicode-emoji (4.2.0) sha256=519e69150f75652e40bf736106cfbc8f0f73aa3fb6a65afe62fefa7f80b0f80f
-  yard (0.9.38) sha256=721fb82afb10532aa49860655f6cc2eaa7130889df291b052e1e6b268283010f
-  yard-lint (1.4.0) sha256=7dd88fbb08fd77cb840bea899d58812817b36d92291b5693dd0eeb3af9f91f0f
-  zeitwerk (2.7.4) sha256=2bef90f356bdafe9a6c2bd32bcd804f83a4f9b8bc27f3600fff051eb3edcec8b
+  yard (0.9.45) sha256=52e211493f7cb8a3ebf7e104a25a1e73937a3103092545d34cb88fafebb3dc51
+  yard-lint (1.10.2) sha256=3e595709d088a8cc827e706a4146b447eb6a907ee375d06c11077369d00717f6
+  zeitwerk (2.8.2) sha256=7212a61311083c604184b1ea2574b9aa05cd14f855a0841c06985cabe9181d12
 
 BUNDLED WITH
-  4.0.3
+  4.0.17

data/bin/cli/sqs.rb

@@ -12,6 +12,14 @@ module Shoryuken
       # @see https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/quotas-messages.html
       MAX_BATCH_SIZE = 1024 * 1024
 
+      # Long-poll wait (seconds) used when draining a queue in find_all, so a
+      # short-poll empty batch doesn't end dump/mv prematurely.
+      FIND_ALL_WAIT_SECONDS = 1
+
+      # Number of consecutive empty long-poll batches before find_all concludes
+      # the queue is drained.
+      FIND_ALL_MAX_EMPTY_BATCHES = 3
+
       namespace :sqs
       class_option :endpoint, aliases: '-e', type: :string, default: ENV['SHORYUKEN_SQS_ENDPOINT'], desc: 'Endpoint URL'
 
@@ -146,6 +154,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
@@ -163,6 +178,25 @@ module Shoryuken
         # @return [Integer] the number of messages received
         def find_all(url, limit, &block)
           count = 0
+          empty_batches = 0
+          # Callers (dump/mv) collect messages and only delete them after this
+          # method returns (so a failed dump/mv deletes nothing), which means
+          # nothing is removed from the queue during the drain. Two consequences:
+          #
+          #   1. A large drain can outlast the queue's visibility timeout, at
+          #      which point already-received messages become visible again and
+          #      are handed back on a later receive. `seen` maps message id to
+          #      the first yielded message so those re-reads are not yielded,
+          #      counted, or dumped/moved twice - but the newest receipt handle
+          #      is copied onto that message, because SQS only honors the most
+          #      recently received handle for deletion (an older one can report
+          #      success yet leave the message in the queue).
+          #   2. Because messages stay in flight until the caller deletes them,
+          #      a queue larger than SQS's in-flight limit (~120k standard /
+          #      ~20k FIFO) cannot be drained in a single pass: once the limit
+          #      is reached receive returns empty and find_all stops. No message
+          #      is lost - re-run dump/mv to drain the remainder.
+          seen = {}
           batch_size = limit > 10 ? 10 : limit
 
           loop do
@@ -172,16 +206,46 @@ module Shoryuken
             messages = sqs.receive_message(
               queue_url: url,
               max_number_of_messages: batch_size,
+              # Long poll: short polling (the default wait_time_seconds: 0)
+              # samples only a subset of SQS hosts and routinely returns an empty
+              # batch even when the queue still has messages, which made dump/mv
+              # stop early and miss messages on real (distributed) SQS.
+              wait_time_seconds: FIND_ALL_WAIT_SECONDS,
               attribute_names: ['All'],
               message_attribute_names: ['All']
             ).messages || []
 
-            messages.each(&block)
+            # Split first-time messages from re-reads (same id handed back after
+            # the visibility timeout lapsed). A batch of only re-reads counts as
+            # empty so the drain still terminates.
+            fresh = []
+            messages.each do |message|
+              if (previous = seen[message.message_id])
+                # Keep the newest receipt handle on the already-yielded message
+                # so the caller's deferred batch_delete targets a handle SQS
+                # still accepts.
+                previous.receipt_handle = message.receipt_handle
+              else
+                seen[message.message_id] = message
+                fresh << message
+              end
+            end
 
-            count += messages.size
+            fresh.each(&block)
+
+            count += fresh.size
 
             break if count >= limit
-            break if messages.empty?
+
+            # Even with long polling an occasional empty batch is possible while
+            # messages remain, so only give up after several consecutive batches
+            # that yielded no new messages.
+            if fresh.empty?
+              empty_batches += 1
+              break if empty_batches >= FIND_ALL_MAX_EMPTY_BATCHES
+            else
+              empty_batches = 0
+            end
           end
 
           count

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/lib/active_job/extensions.rb

@@ -2,9 +2,8 @@
 
 module Shoryuken
   module ActiveJob
-    # Adds an accessor for SQS SendMessage parameters on ActiveJob jobs
-    # (instances of ActiveJob::Base). Shoryuken ActiveJob queue adapters use
-    # these parameters when enqueueing jobs; other adapters can ignore them.
+    # Adds an accessor for SQS SendMessage parameters on ActiveJob jobs (instances of ActiveJob::Base). Shoryuken ActiveJob
+    # queue adapters use these parameters when enqueueing jobs; other adapters can ignore them.
     module SQSSendMessageParametersAccessor
       extend ActiveSupport::Concern
 
@@ -14,14 +13,12 @@ module Shoryuken
       end
     end
 
-    # Initializes SQS SendMessage parameters on instances of ActiveJob::Base
-    # to the empty hash, and populates it whenever `#enqueue` is called, such
-    # as when using ActiveJob::Base.set.
+    # Initializes SQS SendMessage parameters on instances of ActiveJob::Base to the empty hash, and populates it whenever
+    # `#enqueue` is called, such as when using ActiveJob::Base.set.
     module SQSSendMessageParametersSupport
       # Initializes a new ActiveJob instance with empty SQS parameters
       #
-      # Uses argument forwarding (...) to properly pass all arguments including
-      # keyword arguments to the base class.
+      # Uses argument forwarding (...) to properly pass all arguments including keyword arguments to the base class.
       def initialize(...)
         super(...)
         self.sqs_send_message_parameters = {}