sidekiq 4.2.4 → 6.4.0

data/lib/sidekiq/client.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
-require 'securerandom'
-require 'sidekiq/middleware/chain'
+
+require "securerandom"
+require "sidekiq/middleware/chain"
+require "sidekiq/job_util"
 
 module Sidekiq
   class Client
+    include Sidekiq::JobUtil
 
     ##
     # Define client-side middleware:
@@ -19,7 +22,7 @@ module Sidekiq
     #
     def middleware(&block)
       @chain ||= Sidekiq.client_middleware
-      if block_given?
+      if block
         @chain = @chain.dup
         yield @chain
       end
@@ -38,7 +41,7 @@ module Sidekiq
     # Generally this is only needed for very large Sidekiq installs processing
     # thousands of jobs per second.  I don't recommend sharding unless you
     # cannot scale any other way (e.g. splitting your app into smaller apps).
-    def initialize(redis_pool=nil)
+    def initialize(redis_pool = nil)
       @redis_pool = redis_pool || Thread.current[:sidekiq_via_pool] || Sidekiq.redis_pool
     end
 
@@ -48,9 +51,15 @@ module Sidekiq
     #   queue - the named queue to use, default 'default'
     #   class - the worker class to call, required
     #   args - an array of simple arguments to the perform method, must be JSON-serializable
+    #   at - timestamp to schedule the job (optional), must be Numeric (e.g. Time.now.to_f)
     #   retry - whether to retry this job if it fails, default true or an integer number of retries
     #   backtrace - whether to save any error backtrace, default false
     #
+    # If class is set to the class name, the jobs' options will be based on Sidekiq's default
+    # worker options. Otherwise, they will be based on the job class's options.
+    #
+    # Any options valid for a worker class's sidekiq_options are also available here.
+    #
     # All options must be strings, not symbols.  NB: because we are serializing to JSON, all
     # symbols in 'args' will be converted to strings.  Note that +backtrace: true+ can take quite a bit of
     # space in Redis; a large volume of failing jobs can start Redis swapping if you aren't careful.
@@ -62,18 +71,19 @@ module Sidekiq
     #
     def push(item)
       normed = normalize_item(item)
-      payload = process_single(item['class'], normed)
+      payload = process_single(item["class"], normed)
 
       if payload
         raw_push([payload])
-        payload['jid']
+        payload["jid"]
       end
     end
 
     ##
-    # Push a large number of jobs to Redis.  In practice this method is only
-    # useful if you are pushing thousands of jobs or more.  This method
-    # cuts out the redis network round trip latency.
+    # Push a large number of jobs to Redis. This method cuts out the redis
+    # network round trip latency.  I wouldn't recommend pushing more than
+    # 1000 per call but YMMV based on network quality, size of job args, etc.
+    # A large number of jobs can cause a bit of Redis command processing latency.
     #
     # Takes the same arguments as #push except that args is expected to be
     # an Array of Arrays.  All other keys are duplicated for each job.  Each job
@@ -83,19 +93,25 @@ module Sidekiq
     # Returns an array of the of pushed jobs' jids.  The number of jobs pushed can be less
     # than the number given if the middleware stopped processing for one or more jobs.
     def push_bulk(items)
-      arg = items['args'].first
-      return [] unless arg # no jobs to push
-      raise ArgumentError, "Bulk arguments must be an Array of Arrays: [[1], [2]]" if !arg.is_a?(Array)
+      args = items["args"]
+      raise ArgumentError, "Bulk arguments must be an Array of Arrays: [[1], [2]]" unless args.is_a?(Array) && args.all?(Array)
+      return [] if args.empty? # no jobs to push
+
+      at = items.delete("at")
+      raise ArgumentError, "Job 'at' must be a Numeric or an Array of Numeric timestamps" if at && (Array(at).empty? || !Array(at).all? { |entry| entry.is_a?(Numeric) })
+      raise ArgumentError, "Job 'at' Array must have same size as 'args' Array" if at.is_a?(Array) && at.size != args.size
 
       normed = normalize_item(items)
-      payloads = items['args'].map do |args|
-        copy = normed.merge('args' => args, 'jid' => SecureRandom.hex(12), 'enqueued_at' => Time.now.to_f)
-        result = process_single(items['class'], copy)
-        result ? result : nil
-      end.compact
-
-      raw_push(payloads) if !payloads.empty?
-      payloads.collect { |payload| payload['jid'] }
+      payloads = args.map.with_index { |job_args, index|
+        copy = normed.merge("args" => job_args, "jid" => SecureRandom.hex(12), "enqueued_at" => Time.now.to_f)
+        copy["at"] = (at.is_a?(Array) ? at[index] : at) if at
+
+        result = process_single(items["class"], copy)
+        result || nil
+      }.compact
+
+      raw_push(payloads) unless payloads.empty?
+      payloads.collect { |payload| payload["jid"] }
     end
 
     # Allows sharding of jobs across any number of Redis instances.  All jobs
@@ -113,15 +129,13 @@ module Sidekiq
     def self.via(pool)
       raise ArgumentError, "No pool given" if pool.nil?
       current_sidekiq_pool = Thread.current[:sidekiq_via_pool]
-      raise RuntimeError, "Sidekiq::Client.via is not re-entrant" if current_sidekiq_pool && current_sidekiq_pool != pool
       Thread.current[:sidekiq_via_pool] = pool
       yield
     ensure
-      Thread.current[:sidekiq_via_pool] = nil
+      Thread.current[:sidekiq_via_pool] = current_sidekiq_pool
     end
 
     class << self
-
       def push(item)
         new.push(item)
       end
@@ -139,14 +153,14 @@ module Sidekiq
       # Messages are enqueued to the 'default' queue.
       #
       def enqueue(klass, *args)
-        klass.client_push('class' => klass, 'args' => args)
+        klass.client_push("class" => klass, "args" => args)
       end
 
       # Example usage:
       #   Sidekiq::Client.enqueue_to(:queue_name, MyWorker, 'foo', 1, :bat => 'bar')
       #
       def enqueue_to(queue, klass, *args)
-        klass.client_push('queue' => queue, 'class' => klass, 'args' => args)
+        klass.client_push("queue" => queue, "class" => klass, "args" => args)
       end
 
       # Example usage:
@@ -157,8 +171,8 @@ module Sidekiq
         now = Time.now.to_f
         ts = (int < 1_000_000_000 ? now + int : int)
 
-        item = { 'class' => klass, 'args' => args, 'at' => ts, 'queue' => queue }
-        item.delete('at'.freeze) if ts <= now
+        item = {"class" => klass, "args" => args, "at" => ts, "queue" => queue}
+        item.delete("at") if ts <= now
 
         klass.client_push(item)
       end
@@ -175,7 +189,7 @@ module Sidekiq
 
     def raw_push(payloads)
       @redis_pool.with do |conn|
-        conn.multi do
+        conn.pipelined do
           atomic_push(conn, payloads)
         end
       end
@@ -183,54 +197,29 @@ module Sidekiq
     end
 
     def atomic_push(conn, payloads)
-      if payloads.first['at']
-        conn.zadd('schedule'.freeze, payloads.map do |hash|
-          at = hash.delete('at'.freeze).to_s
+      if payloads.first.key?("at")
+        conn.zadd("schedule", payloads.map { |hash|
+          at = hash.delete("at").to_s
           [at, Sidekiq.dump_json(hash)]
-        end)
+        })
       else
-        q = payloads.first['queue']
+        queue = payloads.first["queue"]
         now = Time.now.to_f
-        to_push = payloads.map do |entry|
-          entry['enqueued_at'.freeze] = now
+        to_push = payloads.map { |entry|
+          entry["enqueued_at"] = now
           Sidekiq.dump_json(entry)
-        end
-        conn.sadd('queues'.freeze, q)
-        conn.lpush("queue:#{q}", to_push)
+        }
+        conn.sadd("queues", queue)
+        conn.lpush("queue:#{queue}", to_push)
       end
     end
 
     def process_single(worker_class, item)
-      queue = item['queue']
+      queue = item["queue"]
 
       middleware.invoke(worker_class, item, queue, @redis_pool) do
         item
       end
     end
-
-    def normalize_item(item)
-      raise(ArgumentError, "Job must be a Hash with 'class' and 'args' keys: { 'class' => SomeWorker, 'args' => ['bob', 1, :foo => 'bar'] }") unless item.is_a?(Hash) && item.has_key?('class'.freeze) && item.has_key?('args'.freeze)
-      raise(ArgumentError, "Job args must be an Array") unless item['args'].is_a?(Array)
-      raise(ArgumentError, "Job class must be either a Class or String representation of the class name") unless item['class'.freeze].is_a?(Class) || item['class'.freeze].is_a?(String)
-      #raise(ArgumentError, "Arguments must be native JSON types, see https://github.com/mperham/sidekiq/wiki/Best-Practices") unless JSON.load(JSON.dump(item['args'])) == item['args']
-
-      normalized_hash(item['class'.freeze])
-        .each{ |key, value| item[key] = value if item[key].nil? }
-
-      item['class'.freeze] = item['class'.freeze].to_s
-      item['queue'.freeze] = item['queue'.freeze].to_s
-      item['jid'.freeze] ||= SecureRandom.hex(12)
-      item['created_at'.freeze] ||= Time.now.to_f
-      item
-    end
-
-    def normalized_hash(item_class)
-      if item_class.is_a?(Class)
-        raise(ArgumentError, "Message must include a Sidekiq::Worker class, not class name: #{item_class.ancestors.inspect}") if !item_class.respond_to?('get_sidekiq_options'.freeze)
-        item_class.get_sidekiq_options
-      else
-        Sidekiq.default_worker_options
-      end
-    end
   end
 end

data/lib/sidekiq/delay.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Extensions
+    def self.enable_delay!
+      Sidekiq.logger.error "Sidekiq's Delayed Extensions will be removed in Sidekiq 7.0. #{caller(1..1).first}"
+
+      if defined?(::ActiveSupport)
+        require "sidekiq/extensions/active_record"
+        require "sidekiq/extensions/action_mailer"
+
+        # Need to patch Psych so it can autoload classes whose names are serialized
+        # in the delayed YAML.
+        Psych::Visitors::ToRuby.prepend(Sidekiq::Extensions::PsychAutoload)
+
+        ActiveSupport.on_load(:active_record) do
+          include Sidekiq::Extensions::ActiveRecord
+        end
+        ActiveSupport.on_load(:action_mailer) do
+          extend Sidekiq::Extensions::ActionMailer
+        end
+      end
+
+      require "sidekiq/extensions/class_methods"
+      Module.__send__(:include, Sidekiq::Extensions::Klass)
+    end
+
+    module PsychAutoload
+      def resolve_class(klass_name)
+        return nil if !klass_name || klass_name.empty?
+        # constantize
+        names = klass_name.split("::")
+        names.shift if names.empty? || names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+      rescue NameError
+        super
+      end
+    end
+  end
+end

data/lib/sidekiq/exception_handler.rb

@@ -1,31 +1,27 @@
 # frozen_string_literal: true
-require 'sidekiq'
+
+require "sidekiq"
 
 module Sidekiq
   module ExceptionHandler
-
     class Logger
-      def call(ex, ctxHash)
-        Sidekiq.logger.warn(Sidekiq.dump_json(ctxHash)) if !ctxHash.empty?
-        Sidekiq.logger.warn "#{ex.class.name}: #{ex.message}"
-        Sidekiq.logger.warn ex.backtrace.join("\n") unless ex.backtrace.nil?
+      def call(ex, ctx)
+        Sidekiq.logger.warn(Sidekiq.dump_json(ctx)) unless ctx.empty?
+        Sidekiq.logger.warn("#{ex.class.name}: #{ex.message}")
+        Sidekiq.logger.warn(ex.backtrace.join("\n")) unless ex.backtrace.nil?
       end
 
-      # Set up default handler which just logs the error
       Sidekiq.error_handlers << Sidekiq::ExceptionHandler::Logger.new
     end
 
-    def handle_exception(ex, ctxHash={})
+    def handle_exception(ex, ctx = {})
       Sidekiq.error_handlers.each do |handler|
-        begin
-          handler.call(ex, ctxHash)
-        rescue => ex
-          Sidekiq.logger.error "!!! ERROR HANDLER THREW AN ERROR !!!"
-          Sidekiq.logger.error ex
-          Sidekiq.logger.error ex.backtrace.join("\n") unless ex.backtrace.nil?
-        end
+        handler.call(ex, ctx)
+      rescue => ex
+        Sidekiq.logger.error "!!! ERROR HANDLER THREW AN ERROR !!!"
+        Sidekiq.logger.error ex
+        Sidekiq.logger.error ex.backtrace.join("\n") unless ex.backtrace.nil?
       end
     end
-
   end
 end

data/lib/sidekiq/extensions/action_mailer.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
-require 'sidekiq/extensions/generic_proxy'
+
+require "sidekiq/extensions/generic_proxy"
 
 module Sidekiq
   module Extensions
     ##
-    # Adds 'delay', 'delay_for' and `delay_until` methods to ActionMailer to offload arbitrary email
-    # delivery to Sidekiq.  Example:
+    # Adds +delay+, +delay_for+ and +delay_until+ methods to ActionMailer to offload arbitrary email
+    # delivery to Sidekiq.
     #
+    # @example
     #    UserMailer.delay.send_welcome_email(new_user)
     #    UserMailer.delay_for(5.days).send_welcome_email(new_user)
     #    UserMailer.delay_until(5.days.from_now).send_welcome_email(new_user)
@@ -14,44 +16,33 @@ module Sidekiq
       include Sidekiq::Worker
 
       def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        msg = target.public_send(method_name, *args)
+        (target, method_name, args, kwargs) = YAML.load(yml)
+        msg = kwargs.empty? ? target.public_send(method_name, *args) : target.public_send(method_name, *args, **kwargs)
         # The email method can return nil, which causes ActionMailer to return
         # an undeliverable empty message.
         if msg
-          deliver(msg)
-        else
-          raise "#{target.name}##{method_name} returned an undeliverable mail object"
-        end
-      end
-
-      private
-
-      def deliver(msg)
-        if msg.respond_to?(:deliver_now)
-          # Rails 4.2/5.0
           msg.deliver_now
         else
-          # Rails 3.2/4.0/4.1
-          msg.deliver
+          raise "#{target.name}##{method_name} returned an undeliverable mail object"
         end
       end
     end
 
     module ActionMailer
-      def sidekiq_delay(options={})
+      def sidekiq_delay(options = {})
         Proxy.new(DelayedMailer, self, options)
       end
-      def sidekiq_delay_for(interval, options={})
-        Proxy.new(DelayedMailer, self, options.merge('at' => Time.now.to_f + interval.to_f))
+
+      def sidekiq_delay_for(interval, options = {})
+        Proxy.new(DelayedMailer, self, options.merge("at" => Time.now.to_f + interval.to_f))
       end
-      def sidekiq_delay_until(timestamp, options={})
-        Proxy.new(DelayedMailer, self, options.merge('at' => timestamp.to_f))
+
+      def sidekiq_delay_until(timestamp, options = {})
+        Proxy.new(DelayedMailer, self, options.merge("at" => timestamp.to_f))
       end
       alias_method :delay, :sidekiq_delay
       alias_method :delay_for, :sidekiq_delay_for
       alias_method :delay_until, :sidekiq_delay_until
     end
-
   end
 end

data/lib/sidekiq/extensions/active_record.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
-require 'sidekiq/extensions/generic_proxy'
+
+require "sidekiq/extensions/generic_proxy"
 
 module Sidekiq
   module Extensions
     ##
-    # Adds 'delay', 'delay_for' and `delay_until` methods to ActiveRecord to offload instance method
-    # execution to Sidekiq.  Examples:
+    # Adds +delay+, +delay_for+ and +delay_until+ methods to ActiveRecord to offload instance method
+    # execution to Sidekiq.
     #
-    # User.recent_signups.each { |user| user.delay.mark_as_awesome }
+    # @example
+    #   User.recent_signups.each { |user| user.delay.mark_as_awesome }
     #
     # Please note, this is not recommended as this will serialize the entire
     # object to Redis.  Your Sidekiq jobs should pass IDs, not entire instances.
@@ -16,25 +18,26 @@ module Sidekiq
       include Sidekiq::Worker
 
       def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        target.__send__(method_name, *args)
+        (target, method_name, args, kwargs) = YAML.load(yml)
+        kwargs.empty? ? target.__send__(method_name, *args) : target.__send__(method_name, *args, **kwargs)
       end
     end
 
     module ActiveRecord
-      def sidekiq_delay(options={})
+      def sidekiq_delay(options = {})
         Proxy.new(DelayedModel, self, options)
       end
-      def sidekiq_delay_for(interval, options={})
-        Proxy.new(DelayedModel, self, options.merge('at' => Time.now.to_f + interval.to_f))
+
+      def sidekiq_delay_for(interval, options = {})
+        Proxy.new(DelayedModel, self, options.merge("at" => Time.now.to_f + interval.to_f))
       end
-      def sidekiq_delay_until(timestamp, options={})
-        Proxy.new(DelayedModel, self, options.merge('at' => timestamp.to_f))
+
+      def sidekiq_delay_until(timestamp, options = {})
+        Proxy.new(DelayedModel, self, options.merge("at" => timestamp.to_f))
       end
       alias_method :delay, :sidekiq_delay
       alias_method :delay_for, :sidekiq_delay_for
       alias_method :delay_until, :sidekiq_delay_until
     end
-
   end
 end

data/lib/sidekiq/extensions/class_methods.rb

@@ -1,39 +1,42 @@
 # frozen_string_literal: true
-require 'sidekiq/extensions/generic_proxy'
+
+require "sidekiq/extensions/generic_proxy"
 
 module Sidekiq
   module Extensions
     ##
-    # Adds 'delay', 'delay_for' and `delay_until` methods to all Classes to offload class method
-    # execution to Sidekiq.  Examples:
+    # Adds `delay`, `delay_for` and `delay_until` methods to all Classes to offload class method
+    # execution to Sidekiq.
     #
-    # User.delay.delete_inactive
-    # Wikipedia.delay.download_changes_for(Date.today)
+    # @example
+    #   User.delay.delete_inactive
+    #   Wikipedia.delay.download_changes_for(Date.today)
     #
     class DelayedClass
       include Sidekiq::Worker
 
       def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        target.__send__(method_name, *args)
+        (target, method_name, args, kwargs) = YAML.load(yml)
+        kwargs.empty? ? target.__send__(method_name, *args) : target.__send__(method_name, *args, **kwargs)
       end
     end
 
     module Klass
-      def sidekiq_delay(options={})
+      def sidekiq_delay(options = {})
         Proxy.new(DelayedClass, self, options)
       end
-      def sidekiq_delay_for(interval, options={})
-        Proxy.new(DelayedClass, self, options.merge('at' => Time.now.to_f + interval.to_f))
+
+      def sidekiq_delay_for(interval, options = {})
+        Proxy.new(DelayedClass, self, options.merge("at" => Time.now.to_f + interval.to_f))
       end
-      def sidekiq_delay_until(timestamp, options={})
-        Proxy.new(DelayedClass, self, options.merge('at' => timestamp.to_f))
+
+      def sidekiq_delay_until(timestamp, options = {})
+        Proxy.new(DelayedClass, self, options.merge("at" => timestamp.to_f))
       end
       alias_method :delay, :sidekiq_delay
       alias_method :delay_for, :sidekiq_delay_for
       alias_method :delay_until, :sidekiq_delay_until
     end
-
   end
 end
 

data/lib/sidekiq/extensions/generic_proxy.rb

@@ -1,25 +1,33 @@
 # frozen_string_literal: true
-require 'yaml'
+
+require "yaml"
 
 module Sidekiq
   module Extensions
+    SIZE_LIMIT = 8_192
+
     class Proxy < BasicObject
-      def initialize(performable, target, options={})
+      def initialize(performable, target, options = {})
         @performable = performable
         @target = target
         @opts = options
       end
 
-      def method_missing(name, *args)
+      def method_missing(name, *args, **kwargs)
         # Sidekiq has a limitation in that its message must be JSON.
         # JSON can't round trip real Ruby objects so we use YAML to
         # serialize the objects to a String.  The YAML will be converted
         # to JSON and then deserialized on the other side back into a
         # Ruby object.
-        obj = [@target, name, args]
-        @performable.client_push({ 'class' => @performable, 'args' => [::YAML.dump(obj)] }.merge(@opts))
+        obj = [@target, name, args, kwargs]
+        marshalled = ::YAML.dump(obj)
+        if marshalled.size > SIZE_LIMIT
+          ::Sidekiq.logger.warn { "#{@target}.#{name} job argument is #{marshalled.bytesize} bytes, you should refactor it to reduce the size" }
+        end
+        @performable.client_push({"class" => @performable,
+                                  "args" => [marshalled],
+                                  "display_class" => "#{@target}.#{name}"}.merge(@opts))
       end
     end
-
   end
 end

data/lib/sidekiq/fetch.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'sidekiq'
+
+require "sidekiq"
 
 module Sidekiq
   class BasicFetch
@@ -7,68 +8,60 @@ module Sidekiq
     # can check if the process is shutting down.
     TIMEOUT = 2
 
-    UnitOfWork = Struct.new(:queue, :job) do
+    UnitOfWork = Struct.new(:queue, :job) {
       def acknowledge
         # nothing to do
       end
 
       def queue_name
-        queue.sub(/.*queue:/, ''.freeze)
+        queue.delete_prefix("queue:")
       end
 
       def requeue
         Sidekiq.redis do |conn|
-          conn.rpush("queue:#{queue_name}", job)
+          conn.rpush(queue, job)
         end
       end
-    end
+    }
 
     def initialize(options)
-      @strictly_ordered_queues = !!options[:strict]
-      @queues = options[:queues].map { |q| "queue:#{q}" }
+      raise ArgumentError, "missing queue list" unless options[:queues]
+      @options = options
+      @strictly_ordered_queues = !!@options[:strict]
+      @queues = @options[:queues].map { |q| "queue:#{q}" }
       if @strictly_ordered_queues
-        @queues = @queues.uniq
+        @queues.uniq!
         @queues << TIMEOUT
       end
     end
 
     def retrieve_work
-      work = Sidekiq.redis { |conn| conn.brpop(*queues_cmd) }
-      UnitOfWork.new(*work) if work
-    end
-
-    # Creating the Redis#brpop command takes into account any
-    # configured queue weights. By default Redis#brpop returns
-    # data from the first queue that has pending elements. We
-    # recreate the queue command each time we invoke Redis#brpop
-    # to honor weights and avoid queue starvation.
-    def queues_cmd
-      if @strictly_ordered_queues
-        @queues
-      else
-        queues = @queues.shuffle.uniq
-        queues << TIMEOUT
-        queues
+      qs = queues_cmd
+      # 4825 Sidekiq Pro with all queues paused will return an
+      # empty set of queues with a trailing TIMEOUT value.
+      if qs.size <= 1
+        sleep(TIMEOUT)
+        return nil
       end
-    end
 
+      work = Sidekiq.redis { |conn| conn.brpop(*qs) }
+      UnitOfWork.new(*work) if work
+    end
 
-    # By leaving this as a class method, it can be pluggable and used by the Manager actor. Making it
-    # an instance method will make it async to the Fetcher actor
-    def self.bulk_requeue(inprogress, options)
+    def bulk_requeue(inprogress, options)
       return if inprogress.empty?
 
       Sidekiq.logger.debug { "Re-queueing terminated jobs" }
       jobs_to_requeue = {}
       inprogress.each do |unit_of_work|
-        jobs_to_requeue[unit_of_work.queue_name] ||= []
-        jobs_to_requeue[unit_of_work.queue_name] << unit_of_work.job
+        jobs_to_requeue[unit_of_work.queue] ||= []
+        jobs_to_requeue[unit_of_work.queue] << unit_of_work.job
       end
 
       Sidekiq.redis do |conn|
         conn.pipelined do
           jobs_to_requeue.each do |queue, jobs|
-            conn.rpush("queue:#{queue}", jobs)
+            conn.rpush(queue, jobs)
           end
         end
       end
@@ -77,5 +70,20 @@ module Sidekiq
       Sidekiq.logger.warn("Failed to requeue #{inprogress.size} jobs: #{ex.message}")
     end
 
+    # Creating the Redis#brpop command takes into account any
+    # configured queue weights. By default Redis#brpop returns
+    # data from the first queue that has pending elements. We
+    # recreate the queue command each time we invoke Redis#brpop
+    # to honor weights and avoid queue starvation.
+    def queues_cmd
+      if @strictly_ordered_queues
+        @queues
+      else
+        permute = @queues.shuffle
+        permute.uniq!
+        permute << TIMEOUT
+        permute
+      end
+    end
   end
 end