shoryuken 7.0.3 → 7.0.4

data/lib/shoryuken/launcher.rb

@@ -14,9 +14,8 @@ module Shoryuken
 
     # Indicates whether the launcher is in the process of stopping.
     #
-    # This flag is set to true when either {#stop} or {#stop!} is called,
-    # and is used by ActiveJob adapters to signal jobs that they should
-    # checkpoint and prepare for graceful shutdown.
+    # This flag is set to true when either {#stop} or {#stop!} is called, and is used by ActiveJob adapters to signal jobs
+    # that they should checkpoint and prepare for graceful shutdown.
     #
     # @return [Boolean] true if stopping, false otherwise
     def stopping?
@@ -91,11 +90,9 @@ module Shoryuken
       @managers.each(&:await_dispatching_in_progress)
     end
 
-    # Shuts the executor down, giving in-flight workers up to the configured
-    # timeout to finish before force-killing them so the process can exit.
-    # Used by both the graceful ({#stop}) and immediate ({#stop!}) shutdowns:
-    # a graceful stop still waits for workers, but must not block forever on a
-    # hung one.
+    # Shuts the executor down, giving in-flight workers up to the configured timeout to finish before force-killing them so
+    # the process can exit. Used by both the graceful ({#stop}) and immediate ({#stop!}) shutdowns: a graceful stop still
+    # waits for workers, but must not block forever on a hung one.
     #
     # @return [void]
     def shutdown_executor
@@ -105,11 +102,9 @@ module Shoryuken
 
     # Returns the executor for running async operations
     #
-    # Owns a dedicated executor rather than borrowing Concurrent.global_io_executor:
-    # {#stop} and {#stop!} shut down and kill this executor, and destroying the
-    # process-global pool would break anything else relying on it (including
-    # Shoryuken's own ShoryukenConcurrentSendAdapter) and prevent a fresh launcher
-    # from starting in the same process.
+    # Owns a dedicated executor rather than borrowing Concurrent.global_io_executor: {#stop} and {#stop!} shut down and kill
+    # this executor, and destroying the process-global pool would break anything else relying on it (including Shoryuken's
+    # own ShoryukenConcurrentSendAdapter) and prevent a fresh launcher from starting in the same process.
     #
     # @return [Concurrent::ExecutorService] the executor service
     def executor

data/lib/shoryuken/manager.rb

@@ -32,6 +32,7 @@ module Shoryuken
       @executor                   = executor
       @running                    = Shoryuken::Helpers::AtomicBoolean.new(true)
       @stop_new_dispatching       = Shoryuken::Helpers::AtomicBoolean.new(false)
+      @dispatch_started           = Shoryuken::Helpers::AtomicBoolean.new(false)
       @dispatching_release_signal = ::Queue.new
     end
 
@@ -48,6 +49,14 @@ module Shoryuken
     # @return [void]
     def stop_new_dispatching
       @stop_new_dispatching.make_true
+
+      # If the dispatch loop never ran (e.g. a stop arrives before the start
+      # Future is scheduled, or in an embedded host whose executor is
+      # saturated), there is no loop to observe the flag and close the release
+      # signal, so await_dispatching_in_progress would block forever. Close it
+      # here in that case. Queue#close is idempotent, so a dispatch_loop that
+      # does start later and closes it again is harmless.
+      @dispatching_release_signal.close unless @dispatch_started.true?
     end
 
     # Waits for any in-progress dispatching to complete
@@ -76,6 +85,11 @@ module Shoryuken
     #
     # @return [void]
     def dispatch_loop
+      # Mark that the loop has run at least once so stop_new_dispatching knows
+      # it can rely on the loop to close the release signal (and otherwise
+      # closes it itself to avoid a deadlock).
+      @dispatch_started.make_true
+
       if @stop_new_dispatching.true? || !running?
         # Close (instead of push) so every pending and future
         # await_dispatching_in_progress call returns, not just the first one
@@ -156,7 +170,8 @@ module Shoryuken
     #
     # @param queue_name [String] the queue name
     # @param sqs_msg [Aws::SQS::Types::Message, Array<Aws::SQS::Types::Message>] the message or batch
-    # @return [Concurrent::Promise, nil] the processing promise or nil if not running
+    # @return [Concurrent::Promise, nil] the processing promise, or nil if the manager
+    #   is not running or the executor rejects the worker post
     def assign(queue_name, sqs_msg)
       return unless running?
 
@@ -181,6 +196,17 @@ module Shoryuken
             processor_done(queue_name)
           end
         end
+    rescue Concurrent::RejectedExecutionError
+      # The executor was shut down (or a bounded custom launcher_executor is
+      # saturated) between the running? check above and the post. The promise
+      # body - and therefore processor_done - never ran, so roll back the
+      # increment here. Leaking it would permanently shrink `ready`
+      # (@max_processors - busy) until dispatch stalls and the group stops
+      # processing. The message was never processed, so we must not run the
+      # FIFO message_processed callback - decrement directly instead.
+      @busy_processors.decrement
+      fire_utilization_update_event
+      nil
     end
 
     # Dispatches a batch of messages from a queue

data/lib/shoryuken/message.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
 module Shoryuken
-  # Represents an SQS message received by a Shoryuken worker.
-  # This class wraps the raw AWS SQS message data and provides convenient methods
-  # for interacting with the message, including deletion and visibility timeout management.
+  # Represents an SQS message received by a Shoryuken worker. This class wraps the raw AWS SQS message data and provides
+  # convenient methods for interacting with the message, including deletion and visibility timeout management.
   #
   # Message instances are automatically created by Shoryuken and passed to your
   # worker's `perform` method as the first argument.

data/lib/shoryuken/middleware/chain.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 module Shoryuken
-  # Middleware provides a way to wrap message processing with custom logic,
-  # similar to Rack middleware in web applications. Middleware runs on the server
-  # side and can perform setup, teardown, error handling, and monitoring around
-  # job execution.
+  # Middleware provides a way to wrap message processing with custom logic, similar to Rack middleware in web applications.
+  # Middleware runs on the server side and can perform setup, teardown, error handling, and monitoring around job execution.
   #
   # Middleware classes must implement a `call` method that accepts the worker instance,
   # queue name, and SQS message, and must yield to continue the middleware chain.
@@ -84,9 +82,8 @@ module Shoryuken
   # @see Shoryuken::Middleware::Chain Middleware chain management
   # @see https://github.com/ruby-shoryuken/shoryuken/wiki/Middleware Comprehensive middleware guide
   module Middleware
-    # Manages a chain of middleware classes that will be instantiated and invoked
-    # in sequence around message processing. Provides methods for adding, removing,
-    # and reordering middleware.
+    # Manages a chain of middleware classes that will be instantiated and invoked in sequence around message processing.
+    # Provides methods for adding, removing, and reordering middleware.
     class Chain
       # @return [Array<Entry>] The ordered list of middleware entries
       attr_reader :entries
@@ -121,8 +118,7 @@ module Shoryuken
         entries.delete_if { |entry| entry.klass == klass }
       end
 
-      # Adds middleware to the end of the chain. Does nothing if the middleware
-      # class is already present in the chain.
+      # Adds middleware to the end of the chain. Does nothing if the middleware class is already present in the chain.
       #
       # @param klass [Class] The middleware class to add
       # @param args [Array] Arguments to pass to the middleware constructor
@@ -132,8 +128,7 @@ module Shoryuken
         entries << Entry.new(klass, *args) unless exists?(klass)
       end
 
-      # Adds middleware to the beginning of the chain. Does nothing if the middleware
-      # class is already present in the chain.
+      # Adds middleware to the beginning of the chain. Does nothing if the middleware class is already present in the chain.
       #
       # @param klass [Class] The middleware class to prepend
       # @param args [Array] Arguments to pass to the middleware constructor
@@ -195,8 +190,7 @@ module Shoryuken
         entries.clear
       end
 
-      # Invokes the middleware chain with the given arguments.
-      # Each middleware's call method will be invoked in sequence,
+      # Invokes the middleware chain with the given arguments. Each middleware's call method will be invoked in sequence,
       # with control passed through yielding.
       #
       # @param args [Array] arguments to pass to each middleware

data/lib/shoryuken/middleware/entry.rb

@@ -2,8 +2,7 @@
 
 module Shoryuken
   module Middleware
-    # Represents an entry in a middleware chain, storing the middleware class
-    # and any arguments needed for its instantiation.
+    # Represents an entry in a middleware chain, storing the middleware class and any arguments needed for its instantiation.
     #
     # @api private
     class Entry

data/lib/shoryuken/middleware/server/auto_extend_visibility.rb

@@ -73,11 +73,9 @@ module Shoryuken
 
           private
 
-          # Returns a positive interval at which to re-extend the message's
-          # visibility before it expires, or nil when the visibility timeout is
-          # too short to schedule one. Normally this is EXTEND_UPFRONT_SECONDS
-          # before expiry, but for short timeouts (<= EXTEND_UPFRONT_SECONDS) it
-          # falls back to half the timeout so the timer still fires in time
+          # Returns a positive interval at which to re-extend the message's visibility before it expires, or nil when the
+          # visibility timeout is too short to schedule one. Normally this is EXTEND_UPFRONT_SECONDS before expiry, but for
+          # short timeouts (<= EXTEND_UPFRONT_SECONDS) it falls back to half the timeout so the timer still fires in time
           # instead of TimerTask raising on a non-positive interval.
           #
           # @param visibility_timeout [Integer] the queue's visibility timeout in seconds

data/lib/shoryuken/middleware/server/exponential_backoff_retry.rb

@@ -3,9 +3,8 @@
 module Shoryuken
   module Middleware
     module Server
-      # Middleware that implements exponential backoff retry for failed messages.
-      # When a job fails, the message visibility timeout is adjusted based on
-      # configured retry intervals.
+      # Middleware that implements exponential backoff retry for failed messages. When a job fails, the message visibility
+      # timeout is adjusted based on configured retry intervals.
       class ExponentialBackoffRetry
         include Util
 
@@ -28,24 +27,31 @@ module Shoryuken
           end
 
           started_at = Time.now
-          yield
-        rescue => e
-          worker_options = worker.class.get_shoryuken_options
-          retry_intervals = worker_options['retry_intervals']
-
-          # Non-retryable exceptions must not be backoff retried; re-raise so the
-          # NonRetryableException middleware can delete the message immediately.
-          raise if NonRetryableException.non_retryable?(e, worker_options['non_retryable_exceptions'])
 
-          if retry_intervals.nil? || !handle_failure(sqs_msg, started_at, retry_intervals)
-            # Re-raise the exception if the job is not going to be exponential backoff retried.
-            # This allows custom middleware (like exception notifiers) to be aware of the unhandled failure.
-            raise
+          # Scope the rescue to the single-message yield only. A method-level
+          # rescue would also catch the batch `return yield` above, then route the
+          # Array into handle_failure (which calls #attributes/#message_id on it),
+          # raising a NoMethodError that masks the original worker error.
+          begin
+            yield
+          rescue => e
+            worker_options = worker.class.get_shoryuken_options
+            retry_intervals = worker_options['retry_intervals']
+
+            # Non-retryable exceptions must not be backoff retried; re-raise so the
+            # NonRetryableException middleware can delete the message immediately.
+            raise if NonRetryableException.non_retryable?(e, worker_options['non_retryable_exceptions'])
+
+            if retry_intervals.nil? || !handle_failure(sqs_msg, started_at, retry_intervals)
+              # Re-raise the exception if the job is not going to be exponential backoff retried.
+              # This allows custom middleware (like exception notifiers) to be aware of the unhandled failure.
+              raise
+            end
+
+            logger.warn { "Message #{sqs_msg.message_id} will attempt retry due to error: #{e.message}" }
+            # since we didn't raise, lets log the backtrace for debugging purposes.
+            logger.debug { e.backtrace.join("\n") } unless e.backtrace.nil?
           end
-
-          logger.warn { "Message #{sqs_msg.message_id} will attempt retry due to error: #{e.message}" }
-          # since we didn't raise, lets log the backtrace for debugging purposes.
-          logger.debug { e.backtrace.join("\n") } unless e.backtrace.nil?
         end
 
         private
@@ -69,11 +75,14 @@ module Shoryuken
         #
         # @param interval [Integer] the desired interval
         # @param started_at [Time] when processing started
-        # @return [Integer] the capped visibility timeout
+        # @return [Integer] the capped visibility timeout (never negative)
         def next_visibility_timeout(interval, started_at)
           max_timeout = 43_200 - (Time.now - started_at).ceil - 1
           interval = max_timeout if interval > max_timeout
-          interval.to_i
+          # Never go negative: a job that ran longer than the 12h SQS ceiling
+          # drives max_timeout below zero, and change_message_visibility rejects
+          # a negative timeout. Clamp to 0 (retry as soon as possible) instead.
+          [interval.to_i, 0].max
         end
 
         # Handles a message failure by adjusting visibility timeout
@@ -92,6 +101,14 @@ module Shoryuken
           logger.info { "Message #{sqs_msg.message_id} failed, will be retried in #{interval} seconds" }
 
           true
+        rescue => e
+          # Rescheduling itself failed (e.g. an expired receipt handle, or a
+          # transient SQS error). Don't let that exception escape and mask the
+          # original worker failure - log it and report "not retried" so the
+          # caller re-raises the original error and the message falls back to the
+          # queue's default visibility timeout.
+          logger.warn { "Failed to set backoff visibility timeout for #{sqs_msg.message_id}: #{e.message}" }
+          false
         end
       end
     end

data/lib/shoryuken/middleware/server/timing.rb

@@ -3,9 +3,8 @@
 module Shoryuken
   module Middleware
     module Server
-      # Middleware that logs timing information for message processing.
-      # Records start time, completion time, and warns if processing
-      # exceeds the queue's visibility timeout.
+      # Middleware that logs timing information for message processing. Records start time, completion time, and warns if
+      # processing exceeds the queue's visibility timeout.
       class Timing
         include Util
 

data/lib/shoryuken/options.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
 module Shoryuken
-  # Stores and manages all Shoryuken configuration options.
-  # This class is used internally to hold settings for workers, queues,
-  # middleware, and other runtime configurations.
+  # Stores and manages all Shoryuken configuration options. This class is used internally to hold settings for workers,
+  # queues, middleware, and other runtime configurations.
   class Options
     # Default configuration values for Shoryuken
     DEFAULTS = {
@@ -35,6 +34,7 @@ module Shoryuken
     # @return [Shoryuken::WorkerRegistry] the registry for worker classes
     # @return [Array<#call>] handlers for processing exceptions
     attr_accessor :active_job_queue_name_prefixing, :active_job_fifo_message_deduplication,
+                  :fifo_message_deduplication,
                   :cache_visibility_timeout,
                   :groups, :launcher_executor, :reloader, :enable_reloading,
                   :start_callback, :stop_callback, :worker_executor, :worker_registry,
@@ -55,6 +55,7 @@ module Shoryuken
       self.exception_handlers = [DefaultExceptionHandler]
       self.active_job_queue_name_prefixing = false
       self.active_job_fifo_message_deduplication = true
+      self.fifo_message_deduplication = true
       self.worker_executor = Worker::DefaultExecutor
       self.cache_visibility_timeout = false
       self.reloader = proc { |&block| block.call }
@@ -304,15 +305,36 @@ module Shoryuken
       @active_job_queue_name_prefixing
     end
 
-    # Checks if the ActiveJob adapter should auto-generate a content-based
-    # message_deduplication_id for FIFO queues. When disabled, distinct enqueues
-    # of the same job class and arguments are no longer silently deduplicated.
+    # Checks if the ActiveJob adapter should auto-generate a content-based message_deduplication_id for FIFO queues. When
+    # disabled, distinct enqueues of the same job class and arguments are no longer silently deduplicated.
     #
     # @return [Boolean] true if FIFO deduplication id generation is enabled
     def active_job_fifo_message_deduplication?
       @active_job_fifo_message_deduplication
     end
 
+    # Checks whether Shoryuken auto-generates a content-based
+    # message_deduplication_id for raw FIFO sends (Worker.perform_async,
+    # Queue#send_message / #send_messages). When disabled, distinct sends of an
+    # identical body are no longer silently deduplicated by SQS - you must then
+    # provide a message_deduplication_id yourself or enable
+    # ContentBasedDeduplication on the queue.
+    #
+    # ActiveJob enqueues are primarily controlled by
+    # #active_job_fifo_message_deduplication?. When that is enabled the adapter
+    # sets a content-based message_deduplication_id itself (from the body minus
+    # job_id/enqueued_at) before the raw send, so this flag is a no-op for them.
+    # When it is disabled the adapter omits the id and this flag governs the
+    # fallback: left enabled (the default) each enqueue still gets a hash of the
+    # full serialized body - which includes the per-enqueue job_id, so distinct
+    # enqueues are NOT deduplicated - while disabling it drops the id entirely
+    # (then requiring an explicit id or the queue's ContentBasedDeduplication).
+    #
+    # @return [Boolean] true if FIFO deduplication id generation is enabled
+    def fifo_message_deduplication?
+      @fifo_message_deduplication
+    end
+
     private
 
     # Creates the default server middleware chain

data/lib/shoryuken/polling/base_strategy.rb

@@ -5,10 +5,9 @@ module Shoryuken
   module Polling
     # Abstract base class for queue polling strategies.
     #
-    # This class defines the interface that all polling strategies must implement
-    # to manage queue selection and message flow control in Shoryuken workers.
-    # Polling strategies determine which queue to fetch messages from next and
-    # how to handle scenarios where queues have no messages available.
+    # This class defines the interface that all polling strategies must implement to manage queue selection and message flow
+    # control in Shoryuken workers. Polling strategies determine which queue to fetch messages from next and how to handle
+    # scenarios where queues have no messages available.
     #
     # @abstract Subclass and override {#next_queue}, {#messages_found}, and {#active_queues}
     #   to implement a custom polling strategy.
@@ -42,9 +41,8 @@ module Shoryuken
 
       # Returns the next queue to poll for messages.
       #
-      # This method should return a QueueConfiguration object representing
-      # the next queue that should be polled for messages, or nil if no
-      # queues are currently available for polling.
+      # This method should return a QueueConfiguration object representing the next queue that should be polled for messages,
+      # or nil if no queues are currently available for polling.
       #
       # @abstract Subclasses must implement this method
       # @return [QueueConfiguration, nil] Next queue to poll, or nil if none available
@@ -55,10 +53,9 @@ module Shoryuken
 
       # Called when messages are found (or not found) in a queue.
       #
-      # This method is invoked after polling a queue to inform the strategy
-      # about the number of messages that were retrieved. Strategies can use
-      # this information to make decisions about future polling behavior,
-      # such as pausing empty queues or adjusting queue weights.
+      # This method is invoked after polling a queue to inform the strategy about the number of messages that were retrieved.
+      # Strategies can use this information to make decisions about future polling behavior, such as pausing empty queues or
+      # adjusting queue weights.
       #
       # @abstract Subclasses must implement this method
       # @param _queue [String] The name of the queue that was polled
@@ -70,9 +67,8 @@ module Shoryuken
 
       # Called when a message from a queue has been processed.
       #
-      # This optional callback is invoked after a message has been successfully
-      # processed by a worker. Strategies can use this information for cleanup
-      # or to adjust their polling behavior.
+      # This optional callback is invoked after a message has been successfully processed by a worker. Strategies can use
+      # this information for cleanup or to adjust their polling behavior.
       #
       # @param _queue [String] The name of the queue whose message was processed
       # @return [void]
@@ -80,9 +76,8 @@ module Shoryuken
 
       # Returns the list of currently active queues.
       #
-      # This method should return an array representing the queues that are
-      # currently active and available for polling. The format may vary by
-      # strategy implementation.
+      # This method should return an array representing the queues that are currently active and available for polling. The
+      # format may vary by strategy implementation.
       #
       # @abstract Subclasses must implement this method
       # @return [Array] List of active queues
@@ -93,9 +88,8 @@ module Shoryuken
 
       # Compares this strategy with another object for equality.
       #
-      # Two strategies are considered equal if they have the same active queues.
-      # This method also supports comparison with Array objects for backward
-      # compatibility.
+      # Two strategies are considered equal if they have the same active queues. This method also supports comparison with
+      # Array objects for backward compatibility.
       #
       # @param other [Object] Object to compare with
       # @return [Boolean] true if strategies are equivalent
@@ -114,9 +108,8 @@ module Shoryuken
 
       # Returns the delay time for pausing empty queues.
       #
-      # This method returns the amount of time (in seconds) that empty queues
-      # should be paused before being polled again. The delay can be set at
-      # the strategy level or falls back to the global Shoryuken delay setting.
+      # This method returns the amount of time (in seconds) that empty queues should be paused before being polled again. The
+      # delay can be set at the strategy level or falls back to the global Shoryuken delay setting.
       #
       # @return [Float] Delay time in seconds
       def delay

data/lib/shoryuken/polling/queue_configuration.rb

@@ -4,9 +4,8 @@ module Shoryuken
   module Polling
     # Configuration object representing a queue and its associated options.
     #
-    # This class encapsulates a queue name along with any polling-specific
-    # options or metadata. It provides a structured way to pass queue
-    # information between polling strategies and the message fetching system.
+    # This class encapsulates a queue name along with any polling-specific options or metadata. It provides a structured way
+    # to pass queue information between polling strategies and the message fetching system.
     #
     # The class extends Struct to provide attribute accessors for name and options
     # while adding custom behavior for equality comparison and string representation.
@@ -32,9 +31,8 @@ module Shoryuken
     QueueConfiguration = Struct.new(:name, :options) do
       # Generates a hash value based on the queue name.
       #
-      # This method ensures that QueueConfiguration objects can be used
-      # as hash keys and that configurations with the same queue name
-      # will have the same hash value regardless of their options.
+      # This method ensures that QueueConfiguration objects can be used as hash keys and that configurations with the same
+      # queue name will have the same hash value regardless of their options.
       #
       # @return [Integer] Hash value based on the queue name
       def hash
@@ -43,9 +41,8 @@ module Shoryuken
 
       # Compares this configuration with another object for equality.
       #
-      # Two QueueConfiguration objects are equal if they have the same name
-      # and options. For convenience, a configuration with empty options can
-      # also be compared directly with a string queue name.
+      # Two QueueConfiguration objects are equal if they have the same name and options. For convenience, a configuration
+      # with empty options can also be compared directly with a string queue name.
       #
       # @param other [Object] The object to compare with
       # @return [Boolean] true if the objects are considered equal
@@ -78,9 +75,8 @@ module Shoryuken
 
       # Returns a string representation of the queue configuration.
       #
-      # For configurations with empty options, returns just the queue name.
-      # For configurations with options, returns a detailed representation
-      # showing both the name and the options hash.
+      # For configurations with empty options, returns just the queue name. For configurations with options, returns a
+      # detailed representation showing both the name and the options hash.
       #
       # @return [String] String representation of the configuration
       #

data/lib/shoryuken/polling/weighted_round_robin.rb

@@ -90,10 +90,9 @@ module Shoryuken
 
       # Unpauses the first queue whose delay has expired.
       #
-      # Scans for any expired entry rather than only the head of the list:
-      # message_processed marks a queue ready by setting its time to the epoch,
-      # and that entry may sit behind an earlier-paused queue that is still
-      # paused - checking only the head would leave the ready queue stuck.
+      # Scans for any expired entry rather than only the head of the list: message_processed marks a queue ready by setting
+      # its time to the epoch, and that entry may sit behind an earlier-paused queue that is still paused - checking only the
+      # head would leave the ready queue stuck.
       #
       # @return [void]
       def unpause_queues

data/lib/shoryuken/queue.rb

@@ -89,7 +89,11 @@ module Shoryuken
     # @option options [Array<Hash>] :entries message entries to send
     # @return [Aws::SQS::Types::SendMessageBatchResult] the batch send result
     def send_messages(options)
-      client.send_message_batch(sanitize_messages!(options).merge(queue_url: url))
+      response = client.send_message_batch(sanitize_messages!(options).merge(queue_url: url))
+
+      log_failed_sends(response)
+
+      response
     end
 
     # Receives messages from the queue
@@ -120,6 +124,24 @@ module Shoryuken
 
     private
 
+    # Logs any per-entry failures from a batch send. SQS reports these in
+    # response.failed (throttling, oversize/malformed entries, or a same-batch
+    # duplicate message_deduplication_id) rather than raising, so without this
+    # they are silently swallowed - notably by ShoryukenAdapter#enqueue_all,
+    # which reads only response.successful. Mirrors delete_messages.
+    #
+    # @param response [Aws::SQS::Types::SendMessageBatchResult] the batch result
+    # @return [void]
+    def log_failed_sends(response)
+      return unless response.respond_to?(:failed)
+
+      Array(response.failed).each do |failure|
+        logger.error do
+          "Could not send #{failure.id}, code: '#{failure.code}', message: '#{failure.message}', sender_fault: #{failure.sender_fault}"
+        end
+      end
+    end
+
     # Initializes the FIFO attribute by calling fifo?
     #
     # @return [Boolean] whether the queue is FIFO
@@ -224,8 +246,16 @@ module Shoryuken
     def add_fifo_attributes!(options)
       return unless fifo?
 
-      options[:message_group_id]         ||= MESSAGE_GROUP_ID
-      options[:message_deduplication_id] ||= Digest::SHA256.hexdigest(options[:message_body].to_s)
+      options[:message_group_id] ||= MESSAGE_GROUP_ID
+
+      # Auto-generate a content-based dedup id unless disabled. With it on, two
+      # sends of an identical body within SQS's 5-minute window are deduplicated
+      # (the second is silently dropped); disable it to send such messages
+      # distinctly (requires an explicit message_deduplication_id or the queue's
+      # ContentBasedDeduplication attribute).
+      if Shoryuken.fifo_message_deduplication?
+        options[:message_deduplication_id] ||= Digest::SHA256.hexdigest(options[:message_body].to_s)
+      end
 
       options
     end

data/lib/shoryuken/version.rb

@@ -2,5 +2,5 @@
 
 module Shoryuken
   # Current version of the Shoryuken gem
-  VERSION = '7.0.3'
+  VERSION = '7.0.4'
 end

data/lib/shoryuken/worker/default_executor.rb

@@ -15,11 +15,17 @@ module Shoryuken
         # @option options [String] :queue override the default queue
         # @return [Aws::SQS::Types::SendMessageResult] the send result
         def perform_async(worker_class, body, options = {})
-          options[:message_attributes] ||= {}
-          options[:message_attributes]['shoryuken_class'] = {
-            string_value: worker_class.to_s,
-            data_type: 'String'
-          }
+          # Work on a copy: callers may reuse the same options hash across
+          # enqueues, and mutating it (deleting :queue, adding :message_body)
+          # would silently reroute or corrupt later jobs. Merge - rather than
+          # mutate - the nested :message_attributes hash for the same reason.
+          options = options.dup
+          options[:message_attributes] = (options[:message_attributes] || {}).merge(
+            'shoryuken_class' => {
+              string_value: worker_class.to_s,
+              data_type: 'String'
+            }
+          )
 
           options[:message_body] = body
 

data/lib/shoryuken/worker/inline_executor.rb

@@ -15,13 +15,18 @@ module Shoryuken
         # @option options [Hash] :message_attributes custom message attributes
         # @return [Object] the result of the worker's perform method
         def perform_async(worker_class, body, options = {})
+          # Work on a copy so reused/shared options hashes aren't mutated across
+          # calls (deleting :queue would reroute later jobs to the default
+          # queue). Merge - rather than mutate - the nested message_attributes.
+          options = options.dup
           body = JSON.dump(body) if body.is_a?(Hash)
           queue_name = options.delete(:queue) || worker_class.get_shoryuken_options['queue']
-          message_attributes = options.delete(:message_attributes) || {}
-          message_attributes['shoryuken_class'] = {
-            string_value: worker_class.to_s,
-            data_type: 'String'
-          }
+          message_attributes = (options.delete(:message_attributes) || {}).merge(
+            'shoryuken_class' => {
+              string_value: worker_class.to_s,
+              data_type: 'String'
+            }
+          )
 
           sqs_msg = InlineMessage.new(
             body: body,