shoryuken 7.0.2 → 7.0.4

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

@@ -48,8 +48,17 @@ module Shoryuken
           # @return [Shoryuken::Helpers::TimerTask] the timer task
           def auto_extend(_worker, queue, sqs_msg, _body)
             queue_visibility_timeout = Shoryuken::Client.queues(queue).visibility_timeout
+            execution_interval = extension_interval(queue_visibility_timeout)
 
-            Shoryuken::Helpers::TimerTask.new(execution_interval: queue_visibility_timeout - EXTEND_UPFRONT_SECONDS) do
+            unless execution_interval
+              logger.warn do
+                "Not auto-extending visibility for #{queue}/#{sqs_msg.message_id}: queue visibility " \
+                "timeout (#{queue_visibility_timeout}s) is too short. Increase it to use auto_visibility_timeout."
+              end
+              return nil
+            end
+
+            Shoryuken::Helpers::TimerTask.new(execution_interval: execution_interval) do
               logger.debug do
                 "Extending message #{queue}/#{sqs_msg.message_id} visibility timeout by #{queue_visibility_timeout}s"
               end
@@ -61,6 +70,23 @@ module Shoryuken
               end
             end
           end
+
+          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
+          # instead of TimerTask raising on a non-positive interval.
+          #
+          # @param visibility_timeout [Integer] the queue's visibility timeout in seconds
+          # @return [Float, Integer, nil] the execution interval, or nil if too short
+          def extension_interval(visibility_timeout)
+            return nil if visibility_timeout <= 0
+
+            interval = visibility_timeout - EXTEND_UPFRONT_SECONDS
+            interval = visibility_timeout / 2.0 if interval <= 0
+            interval
+          end
         end
 
         # Creates and starts a visibility extension timer
@@ -71,7 +97,9 @@ module Shoryuken
         # @param body [Object] the parsed message body
         # @return [Shoryuken::Helpers::TimerTask] the started timer
         def auto_visibility_timer(worker, queue, sqs_msg, body)
-          MessageVisibilityExtender.new.auto_extend(worker, queue, sqs_msg, body).tap(&:execute)
+          timer = MessageVisibilityExtender.new.auto_extend(worker, queue, sqs_msg, body)
+          timer&.execute
+          timer
         end
       end
     end

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
 
@@ -17,8 +16,8 @@ module Shoryuken
         # @param _body [Object] the parsed message body (unused)
         # @yield continues to the next middleware in the chain
         # @return [void]
-        # @raise [StandardError] re-raises the original exception if retry intervals are not configured
-        #   or if retry limit is exceeded
+        # @raise [StandardError] re-raises the original exception if retry intervals are not configured,
+        #   if retry limit is exceeded, or if the exception is classified as non-retryable
         def call(worker, _queue, sqs_msg, _body)
           return yield unless worker.class.exponential_backoff?
 
@@ -28,19 +27,31 @@ module Shoryuken
           end
 
           started_at = Time.now
-          yield
-        rescue => e
-          retry_intervals = worker.class.get_shoryuken_options['retry_intervals']
 
-          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
+          # 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'])
 
-          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?
+            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
         end
 
         private
@@ -64,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
@@ -87,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/non_retryable_exception.rb

@@ -28,6 +28,22 @@ module Shoryuken
       class NonRetryableException
         include Util
 
+        # Checks whether an exception is classified as non-retryable for a worker
+        #
+        # @param exception [Exception] the exception to classify
+        # @param non_retryable_exceptions [Array<Class>, #call, nil] the worker's
+        #   non_retryable_exceptions option: exception classes or a callable
+        # @return [Boolean] true if the exception must not be retried
+        def self.non_retryable?(exception, non_retryable_exceptions)
+          return false unless non_retryable_exceptions
+
+          if non_retryable_exceptions.respond_to?(:call)
+            !!non_retryable_exceptions.call(exception)
+          else
+            Array(non_retryable_exceptions).any? { |klass| exception.is_a?(klass) }
+          end
+        end
+
         # Processes a message and handles non-retryable exceptions
         #
         # @param worker [Object] the worker instance
@@ -41,14 +57,7 @@ module Shoryuken
         rescue => e
           non_retryable_exceptions = worker.class.get_shoryuken_options['non_retryable_exceptions']
 
-          return raise unless non_retryable_exceptions
-
-          if non_retryable_exceptions.respond_to?(:call)
-            return raise unless non_retryable_exceptions.call(e)
-          else
-            exception_classes = Array(non_retryable_exceptions)
-            return raise unless exception_classes.any? { |klass| e.is_a?(klass) }
-          end
+          return raise unless self.class.non_retryable?(e, non_retryable_exceptions)
 
           # Handle batch messages
           messages = sqs_msg.is_a?(Array) ? sqs_msg : [sqs_msg]

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 = {
@@ -34,7 +33,9 @@ module Shoryuken
     # @return [Class] the executor class for running workers
     # @return [Shoryuken::WorkerRegistry] the registry for worker classes
     # @return [Array<#call>] handlers for processing exceptions
-    attr_accessor :active_job_queue_name_prefixing, :cache_visibility_timeout,
+    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,
                   :exception_handlers
@@ -53,6 +54,8 @@ module Shoryuken
       self.worker_registry = DefaultWorkerRegistry.new
       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 }
@@ -302,6 +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.
+    #
+    # @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/strict_priority.rb

@@ -22,6 +22,10 @@ module Shoryuken
                         .each_with_object({}) { |queue, h| h[queue] = Time.at(0) }
 
         @delay = delay
+        # next_queue/messages_found run on the dispatch thread while
+        # message_processed runs on processor-completion threads (for FIFO
+        # queues), so all access to the shared state is serialized.
+        @mutex = Mutex.new
         # Start queues at 0
         reset_next_queue
       end
@@ -30,8 +34,10 @@ module Shoryuken
       #
       # @return [QueueConfiguration, nil] the next queue configuration or nil if all paused
       def next_queue
-        next_queue = next_active_queue
-        next_queue.nil? ? nil : QueueConfiguration.new(next_queue, {})
+        @mutex.synchronize do
+          next_queue = next_active_queue
+          next_queue.nil? ? nil : QueueConfiguration.new(next_queue, {})
+        end
       end
 
       # Handles the result of polling a queue
@@ -40,10 +46,12 @@ module Shoryuken
       # @param messages_found [Integer] number of messages found
       # @return [void]
       def messages_found(queue, messages_found)
-        if messages_found == 0
-          pause(queue)
-        else
-          reset_next_queue
+        @mutex.synchronize do
+          if messages_found == 0
+            pause(queue)
+          else
+            reset_next_queue
+          end
         end
       end
 
@@ -51,11 +59,13 @@ module Shoryuken
       #
       # @return [Array<Array>] array of [queue_name, priority] pairs
       def active_queues
-        @queues
-          .reverse
-          .map.with_index(1)
-          .reject { |q, _| queue_paused?(q) }
-          .reverse
+        @mutex.synchronize do
+          @queues
+            .reverse
+            .map.with_index(1)
+            .reject { |q, _| queue_paused?(q) }
+            .reverse
+        end
       end
 
       # Called when a message from a queue has been processed
@@ -63,9 +73,11 @@ module Shoryuken
       # @param queue [String] the queue name
       # @return [void]
       def message_processed(queue)
-        if queue_paused?(queue)
-          logger.debug "Unpausing #{queue}"
-          @paused_until[queue] = Time.at 0
+        @mutex.synchronize do
+          if queue_paused?(queue)
+            logger.debug "Unpausing #{queue}"
+            @paused_until[queue] = Time.at(0)
+          end
         end
       end
 

data/lib/shoryuken/polling/weighted_round_robin.rb

@@ -15,18 +15,26 @@ module Shoryuken
         @queues = queues.dup.uniq
         @paused_queues = []
         @delay = delay
+        # next_queue/messages_found run on the dispatch thread while
+        # message_processed runs on processor-completion threads (for FIFO
+        # queues), so all access to the shared state is serialized.
+        @mutex = Mutex.new
       end
 
       # Returns the next queue to poll in round-robin order
       #
       # @return [QueueConfiguration, nil] the next queue configuration or nil if all paused
       def next_queue
-        unpause_queues
-        queue = @queues.shift
-        return nil if queue.nil?
-
-        @queues << queue
-        QueueConfiguration.new(queue, {})
+        @mutex.synchronize do
+          unpause_queues
+          queue = @queues.shift
+          if queue.nil?
+            nil
+          else
+            @queues << queue
+            QueueConfiguration.new(queue, {})
+          end
+        end
       end
 
       # Handles the result of polling a queue, adjusting weight if messages were found
@@ -35,16 +43,17 @@ module Shoryuken
       # @param messages_found [Integer] number of messages found
       # @return [void]
       def messages_found(queue, messages_found)
-        if messages_found == 0
-          pause(queue)
-          return
-        end
-
-        maximum_weight = maximum_queue_weight(queue)
-        current_weight = current_queue_weight(queue)
-        if maximum_weight > current_weight
-          logger.info { "Increasing #{queue} weight to #{current_weight + 1}, max: #{maximum_weight}" }
-          @queues << queue
+        @mutex.synchronize do
+          if messages_found == 0
+            pause(queue)
+          else
+            maximum_weight = maximum_queue_weight(queue)
+            current_weight = current_queue_weight(queue)
+            if maximum_weight > current_weight
+              logger.info { "Increasing #{queue} weight to #{current_weight + 1}, max: #{maximum_weight}" }
+              @queues << queue
+            end
+          end
         end
       end
 
@@ -52,7 +61,7 @@ module Shoryuken
       #
       # @return [Array<Array>] array of [queue_name, weight] pairs
       def active_queues
-        unparse_queues(@queues)
+        @mutex.synchronize { unparse_queues(@queues) }
       end
 
       # Called when a message from a queue has been processed
@@ -60,10 +69,10 @@ module Shoryuken
       # @param queue [String] the queue name
       # @return [void]
       def message_processed(queue)
-        paused_queue = @paused_queues.find { |_time, name| name == queue }
-        return unless paused_queue
-
-        paused_queue[0] = Time.at 0
+        @mutex.synchronize do
+          paused_queue = @paused_queues.find { |_time, name| name == queue }
+          paused_queue[0] = Time.at(0) if paused_queue
+        end
       end
 
       private
@@ -79,16 +88,20 @@ module Shoryuken
         logger.debug "Paused #{queue}"
       end
 
-      # Unpauses queues whose delay has expired
+      # 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.
       #
       # @return [void]
       def unpause_queues
-        return if @paused_queues.empty?
-        return if Time.now < @paused_queues.first[0]
+        index = @paused_queues.index { |time, _name| time <= Time.now }
+        return if index.nil?
 
-        pause = @paused_queues.shift
-        @queues << pause[1]
-        logger.debug "Unpaused #{pause[1]}"
+        paused = @paused_queues.delete_at(index)
+        @queues << paused[1]
+        logger.debug "Unpaused #{paused[1]}"
       end
 
       # Returns the current weight of a queue in the active rotation