sidekiq 2.15.1 → 4.2.10

data/lib/sidekiq/cli.rb

@@ -1,25 +1,28 @@
+# encoding: utf-8
+# frozen_string_literal: true
 $stdout.sync = true
 
 require 'yaml'
 require 'singleton'
 require 'optparse'
 require 'erb'
+require 'fileutils'
 
 require 'sidekiq'
 require 'sidekiq/util'
 
 module Sidekiq
-  # We are shutting down Sidekiq but what about workers that
-  # are working on some long job?  This error is
-  # raised in workers that have not finished within the hard
-  # timeout limit.  This is needed to rollback db transactions,
-  # otherwise Ruby's Thread#kill will commit.  See #377.
-  # DO NOT RESCUE THIS ERROR.
-  class Shutdown < Interrupt; end
-
   class CLI
     include Util
-    include Singleton
+    include Singleton unless $TESTING
+
+    PROCTITLES = [
+      proc { 'sidekiq'.freeze },
+      proc { Sidekiq::VERSION },
+      proc { |me, data| data['tag'] },
+      proc { |me, data| "[#{Processor::WORKER_STATE.size} of #{data['concurrency']} busy]" },
+      proc { |me, data| "stopping" if me.stopping? },
+    ]
 
     # Used for CLI testing
     attr_accessor :code
@@ -38,22 +41,45 @@ module Sidekiq
       validate!
       daemonize
       write_pid
-      load_celluloid
-      boot_system
     end
 
+    # Code within this method is not tested because it alters
+    # global process state irreversibly.  PRs which improve the
+    # test coverage of Sidekiq::CLI are welcomed.
     def run
+      boot_system
+      print_banner
+
       self_read, self_write = IO.pipe
 
-      %w(INT TERM USR1 USR2 TTIN).each do |sig|
-        trap sig do
-          self_write.puts(sig)
+      %w(INT TERM USR1 USR2 TTIN TSTP).each do |sig|
+        begin
+          trap sig do
+            self_write.puts(sig)
+          end
+        rescue ArgumentError
+          puts "Signal #{sig} not supported"
         end
       end
 
-      redis {} # noop to connect redis and print info
       logger.info "Running in #{RUBY_DESCRIPTION}"
       logger.info Sidekiq::LICENSE
+      logger.info "Upgrade to Sidekiq Pro for more features and support: http://sidekiq.org" unless defined?(::Sidekiq::Pro)
+
+      # touch the connection pool so it is created before we
+      # fire startup and start multithreading.
+      ver = Sidekiq.redis_info['redis_version']
+      raise "You are using Redis v#{ver}, Sidekiq requires Redis v2.8.0 or greater" if ver < '2.8'
+
+      # Touch middleware so it isn't lazy loaded by multiple threads, #3043
+      Sidekiq.server_middleware
+
+      # Before this point, the process is initializing with just the main thread.
+      # Starting here the process will now have multiple threads running.
+      fire_event(:startup)
+
+      logger.debug { "Client Middleware: #{Sidekiq.client_middleware.map(&:klass).join(', ')}" }
+      logger.debug { "Server Middleware: #{Sidekiq.server_middleware.map(&:klass).join(', ')}" }
 
       if !options[:daemon]
         logger.info 'Starting processing, hit Ctrl-C to stop'
@@ -61,13 +87,8 @@ module Sidekiq
 
       require 'sidekiq/launcher'
       @launcher = Sidekiq::Launcher.new(options)
-      launcher.procline(options[:tag] ? "#{options[:tag]} " : '')
 
       begin
-        if options[:profile]
-          require 'ruby-prof'
-          RubyProf.start
-        end
         launcher.run
 
         while readable_io = IO.select([self_read])
@@ -79,23 +100,32 @@ module Sidekiq
         launcher.stop
         # Explicitly exit so busy Processor threads can't block
         # process shutdown.
+        logger.info "Bye!"
         exit(0)
       end
     end
 
-    private
+    def self.banner
+%q{
+         m,
+         `$b
+    .ss,  $$:         .,d$
+    `$$P,d$P'    .,md$P"'
+     ,$$$$$bmmd$$$P^'
+   .d$$$$$$$$$$P'
+   $$^' `"^$$$'       ____  _     _      _    _
+   $:     ,$$:       / ___|(_) __| | ___| | _(_) __ _
+   `b     :$$        \___ \| |/ _` |/ _ \ |/ / |/ _` |
+          $$:         ___) | | (_| |  __/   <| | (_| |
+          $$         |____/|_|\__,_|\___|_|\_\_|\__, |
+        .d$$                                       |_|
+}
+    end
 
     def handle_signal(sig)
       Sidekiq.logger.debug "Got #{sig} signal"
       case sig
       when 'INT'
-        if Sidekiq.options[:profile]
-          result = RubyProf.stop
-          printer = RubyProf::GraphHtmlPrinter.new(result)
-          File.open("profile.html", 'w') do |f|
-            printer.print(f, :min_percent => 1)
-          end
-        end
         # Handle Ctrl-C in JRuby like MRI
         # http://jira.codehaus.org/browse/JRUBY-4637
         raise Interrupt
@@ -104,35 +134,37 @@ module Sidekiq
         raise Interrupt
       when 'USR1'
         Sidekiq.logger.info "Received USR1, no longer accepting new work"
-        launcher.manager.async.stop
+        launcher.quiet
+      when 'TSTP'
+        # USR1 is not available on JVM, allow TSTP as an alternate signal
+        Sidekiq.logger.info "Received TSTP, no longer accepting new work"
+        launcher.quiet
       when 'USR2'
         if Sidekiq.options[:logfile]
           Sidekiq.logger.info "Received USR2, reopening log file"
-          initialize_logger
+          Sidekiq::Logging.reopen_logs
         end
       when 'TTIN'
         Thread.list.each do |thread|
-          Sidekiq.logger.info "Thread TID-#{thread.object_id.to_s(36)} #{thread['label']}"
+          Sidekiq.logger.warn "Thread TID-#{thread.object_id.to_s(36)} #{thread['sidekiq_label']}"
           if thread.backtrace
-            Sidekiq.logger.info thread.backtrace.join("\n")
+            Sidekiq.logger.warn thread.backtrace.join("\n")
           else
-            Sidekiq.logger.info "<no backtrace available>"
+            Sidekiq.logger.warn "<no backtrace available>"
           end
         end
       end
     end
 
-    def load_celluloid
-      raise "Celluloid cannot be required until here, or it will break Sidekiq's daemonization" if defined?(::Celluloid) && options[:daemon]
-
-      # Celluloid can't be loaded until after we've daemonized
-      # because it spins up threads and creates locks which get
-      # into a very bad state if forked.
-      require 'celluloid/autostart'
-      Celluloid.logger = (options[:verbose] ? Sidekiq.logger : nil)
+    private
 
-      require 'sidekiq/manager'
-      require 'sidekiq/scheduled'
+    def print_banner
+      # Print logo and banner for development
+      if environment == 'development' && $stdout.tty?
+        puts "\e[#{31}m"
+        puts Sidekiq::CLI.banner
+        puts "\e[0m"
+      end
     end
 
     def daemonize
@@ -144,7 +176,7 @@ module Sidekiq
         files_to_reopen << file unless file.closed?
       end
 
-      Process.daemon(true, true)
+      ::Process.daemon(true, true)
 
       files_to_reopen.each do |file|
         begin
@@ -169,18 +201,21 @@ module Sidekiq
       @environment = cli_env || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
     end
 
-    def die(code)
-      exit(code)
-    end
+    alias_method :die, :exit
+    alias_method :☠, :exit
 
     def setup_options(args)
-      cli = parse_options(args)
-      set_environment cli[:environment]
+      opts = parse_options(args)
+      set_environment opts[:environment]
 
-      cfile = cli[:config_file]
+      cfile = opts[:config_file]
+      opts = parse_config(cfile).merge(opts) if cfile
 
-      config = (cfile ? parse_config(cfile) : {})
-      options.merge!(config.merge(cli))
+      opts[:strict] = true if opts[:strict].nil?
+      opts[:concurrency] = Integer(ENV["RAILS_MAX_THREADS"]) if !opts[:concurrency] && ENV["RAILS_MAX_THREADS"]
+      opts[:identity] = identity
+
+      options.merge!(opts)
     end
 
     def options
@@ -194,12 +229,30 @@ module Sidekiq
 
       if File.directory?(options[:require])
         require 'rails'
-        require 'sidekiq/rails'
-        require File.expand_path("#{options[:require]}/config/environment.rb")
-        ::Rails.application.eager_load!
+        if ::Rails::VERSION::MAJOR < 4
+          require 'sidekiq/rails'
+          require File.expand_path("#{options[:require]}/config/environment.rb")
+          ::Rails.application.eager_load!
+        elsif ::Rails::VERSION::MAJOR == 4
+          # Painful contortions, see 1791 for discussion
+          # No autoloading, we want to force eager load for everything.
+          require File.expand_path("#{options[:require]}/config/application.rb")
+          ::Rails::Application.initializer "sidekiq.eager_load" do
+            ::Rails.application.config.eager_load = true
+          end
+          require 'sidekiq/rails'
+          require File.expand_path("#{options[:require]}/config/environment.rb")
+        else
+          # Rails 5+ && development mode, use Reloader
+          require 'sidekiq/rails'
+          require File.expand_path("#{options[:require]}/config/environment.rb")
+        end
         options[:tag] ||= default_tag
       else
-        require options[:require]
+        not_required_message = "#{options[:require]} was not required, you should use an explicit path: " +
+            "./#{options[:require]} or /path/to/#{options[:require]}"
+
+        require(options[:require]) || raise(ArgumentError, not_required_message)
       end
     end
 
@@ -226,6 +279,10 @@ module Sidekiq
         logger.info @parser
         die(1)
       end
+
+      [:concurrency, :timeout].each do |opt|
+        raise ArgumentError, "#{opt}: #{options[opt]} is not a valid value" if options.has_key?(opt) && options[opt].to_i <= 0
+      end
     end
 
     def parse_options(argv)
@@ -252,13 +309,9 @@ module Sidekiq
           opts[:index] = Integer(arg.match(/\d+/)[0])
         end
 
-        o.on '-p', '--profile', "Profile all code run by Sidekiq" do |arg|
-          opts[:profile] = arg
-        end
-
-        o.on "-q", "--queue QUEUE[,WEIGHT]...", "Queues to process with optional weights" do |arg|
-          queues_and_weights = arg.scan(/([\w\.-]+),?(\d*)/)
-          parse_queues opts, queues_and_weights
+        o.on "-q", "--queue QUEUE[,WEIGHT]", "Queues to process with optional weights" do |arg|
+          queue, weight = arg.split(",")
+          parse_queue opts, queue, weight
         end
 
         o.on '-r', '--require [PATH|DIR]', "Location of Rails application with workers or file to require" do |arg|
@@ -297,19 +350,25 @@ module Sidekiq
         die 1
       end
       @parser.parse!(argv)
+
+      %w[config/sidekiq.yml config/sidekiq.yml.erb].each do |filename|
+        opts[:config_file] ||= filename if File.exist?(filename)
+      end
+
       opts
     end
 
     def initialize_logger
       Sidekiq::Logging.initialize_logger(options[:logfile]) if options[:logfile]
 
-      Sidekiq.logger.level = Logger::DEBUG if options[:verbose]
+      Sidekiq.logger.level = ::Logger::DEBUG if options[:verbose]
     end
 
     def write_pid
       if path = options[:pidfile]
-        File.open(path, 'w') do |f|
-          f.puts Process.pid
+        pidfile = File.expand_path(path)
+        File.open(pidfile, 'w') do |f|
+          f.puts ::Process.pid
         end
       end
     end
@@ -317,7 +376,7 @@ module Sidekiq
     def parse_config(cfile)
       opts = {}
       if File.exist?(cfile)
-        opts = YAML.load(ERB.new(IO.read(cfile)).result)
+        opts = YAML.load(ERB.new(IO.read(cfile)).result) || opts
         opts = opts.merge(opts.delete(environment) || {})
         parse_queues(opts, opts.delete(:queues) || [])
       else
@@ -326,21 +385,22 @@ module Sidekiq
       end
       ns = opts.delete(:namespace)
       if ns
-        Sidekiq.logger.warn("namespace should be set in your ruby initializer, is ignored in config file")
-        Sidekiq.logger.warn("config.redis = { :url => ..., :namespace => '#{ns}' }")
+        # logger hasn't been initialized yet, puts is all we have.
+        puts("namespace should be set in your ruby initializer, is ignored in config file")
+        puts("config.redis = { :url => ..., :namespace => '#{ns}' }")
       end
       opts
     end
 
     def parse_queues(opts, queues_and_weights)
-      queues_and_weights.each {|queue_and_weight| parse_queue(opts, *queue_and_weight)}
-      opts[:strict] = queues_and_weights.all? {|_, weight| weight.to_s.empty? }
+      queues_and_weights.each { |queue_and_weight| parse_queue(opts, *queue_and_weight) }
     end
 
     def parse_queue(opts, q, weight=nil)
       [weight.to_i, 1].max.times do
        (opts[:queues] ||= []) << q
       end
+      opts[:strict] = false if weight.to_i > 0
     end
   end
 end

data/lib/sidekiq/client.rb

@@ -1,73 +1,133 @@
+# frozen_string_literal: true
 require 'securerandom'
-
 require 'sidekiq/middleware/chain'
 
 module Sidekiq
   class Client
-    class << self
 
-      def default_middleware
-        Middleware::Chain.new do
-        end
+    ##
+    # Define client-side middleware:
+    #
+    #   client = Sidekiq::Client.new
+    #   client.middleware do |chain|
+    #     chain.use MyClientMiddleware
+    #   end
+    #   client.push('class' => 'SomeWorker', 'args' => [1,2,3])
+    #
+    # All client instances default to the globally-defined
+    # Sidekiq.client_middleware but you can change as necessary.
+    #
+    def middleware(&block)
+      @chain ||= Sidekiq.client_middleware
+      if block_given?
+        @chain = @chain.dup
+        yield @chain
       end
+      @chain
+    end
 
-      def registered_workers
-        Sidekiq.redis { |x| x.smembers('workers') }
-      end
+    attr_accessor :redis_pool
+
+    # Sidekiq::Client normally uses the default Redis pool but you may
+    # pass a custom ConnectionPool if you want to shard your
+    # Sidekiq jobs across several Redis instances (for scalability
+    # reasons, e.g.)
+    #
+    #   Sidekiq::Client.new(ConnectionPool.new { Redis.new })
+    #
+    # 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)
+      @redis_pool = redis_pool || Thread.current[:sidekiq_via_pool] || Sidekiq.redis_pool
+    end
 
-      def registered_queues
-        Sidekiq.redis { |x| x.smembers('queues') }
+    ##
+    # The main method used to push a job to Redis.  Accepts a number of options:
+    #
+    #   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
+    #   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
+    #
+    # 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.
+    #
+    # Returns a unique Job ID.  If middleware stops the job, nil will be returned instead.
+    #
+    # Example:
+    #   push('queue' => 'my_queue', 'class' => MyWorker, 'args' => ['foo', 1, :bat => 'bar'])
+    #
+    def push(item)
+      normed = normalize_item(item)
+      payload = process_single(item['class'], normed)
+
+      if payload
+        raw_push([payload])
+        payload['jid']
       end
+    end
 
-      ##
-      # The main method used to push a job to Redis.  Accepts a number of options:
-      #
-      #   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
-      #   retry - whether to retry this job if it fails, true or false, default true
-      #   backtrace - whether to save any error backtrace, default false
-      #
-      # All options must be strings, not symbols.  NB: because we are serializing to JSON, all
-      # symbols in 'args' will be converted to strings.
-      #
-      # Returns nil if not pushed to Redis or a unique Job ID if pushed.
-      #
-      # Example:
-      #   Sidekiq::Client.push('queue' => 'my_queue', 'class' => MyWorker, 'args' => ['foo', 1, :bat => 'bar'])
-      #
-      def push(item)
-        normed = normalize_item(item)
-        payload = process_single(item['class'], normed)
+    ##
+    # 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.
+    #
+    # 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
+    # is run through the client middleware pipeline and each job gets its own Job ID
+    # as normal.
+    #
+    # 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)
+
+      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'] }
+    end
+
+    # Allows sharding of jobs across any number of Redis instances.  All jobs
+    # defined within the block will use the given Redis connection pool.
+    #
+    #   pool = ConnectionPool.new { Redis.new }
+    #   Sidekiq::Client.via(pool) do
+    #     SomeWorker.perform_async(1,2,3)
+    #     SomeOtherWorker.perform_async(1,2,3)
+    #   end
+    #
+    # Generally this is only needed for very large Sidekiq installs processing
+    # thousands of jobs per second.  I do not recommend sharding unless
+    # you cannot scale any other way (e.g. splitting your app into smaller apps).
+    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
+    end
+
+    class << self
 
-        pushed = false
-        pushed = raw_push([payload]) if payload
-        pushed ? payload['jid'] : nil
+      def push(item)
+        new.push(item)
       end
 
-      ##
-      # Push a large number of jobs to Redis.  In practice this method is only
-      # useful if you are pushing tens of thousands of jobs or more.  This method
-      # basically cuts down on the redis round trip latency.
-      #
-      # Takes the same arguments as Client.push except that args is expected to be
-      # an Array of Arrays.  All other keys are duplicated for each job.  Each job
-      # is run through the client middleware pipeline and each job gets its own Job ID
-      # as normal.
-      #
-      # Returns the number of jobs pushed or nil if the pushed failed.  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)
-        normed = normalize_item(items)
-        payloads = items['args'].map do |args|
-          raise ArgumentError, "Bulk arguments must be an Array of Arrays: [[1], [2]]" if !args.is_a?(Array)
-          process_single(items['class'], normed.merge('args' => args, 'jid' => SecureRandom.hex(12), 'enqueued_at' => Time.now.to_f))
-        end.compact
-
-        pushed = false
-        pushed = raw_push(payloads) if !payloads.empty?
-        pushed ? payloads.size : nil
+        new.push_bulk(items)
       end
 
       # Resque compatibility helpers.  Note all helpers
@@ -98,7 +158,7 @@ module Sidekiq
         ts = (int < 1_000_000_000 ? now + int : int)
 
         item = { 'class' => klass, 'args' => args, 'at' => ts, 'queue' => queue }
-        item.delete('at') if ts <= now
+        item.delete('at'.freeze) if ts <= now
 
         klass.client_push(item)
       end
@@ -109,56 +169,68 @@ module Sidekiq
       def enqueue_in(interval, klass, *args)
         klass.perform_in(interval, *args)
       end
+    end
 
-      private
-
-      def raw_push(payloads)
-        pushed = false
-        Sidekiq.redis do |conn|
-          if payloads.first['at']
-            pushed = conn.zadd('schedule', payloads.map do |hash|
-              at = hash.delete('at').to_s
-              [at, Sidekiq.dump_json(hash)]
-            end)
-          else
-            q = payloads.first['queue']
-            to_push = payloads.map { |entry| Sidekiq.dump_json(entry) }
-            _, pushed = conn.multi do
-              conn.sadd('queues', q)
-              conn.lpush("queue:#{q}", to_push)
-            end
-          end
+    private
+
+    def raw_push(payloads)
+      @redis_pool.with do |conn|
+        conn.multi do
+          atomic_push(conn, payloads)
         end
-        pushed
       end
+      true
+    end
 
-      def process_single(worker_class, item)
-        queue = item['queue']
-
-        Sidekiq.client_middleware.invoke(worker_class, item, queue) do
-          item
+    def atomic_push(conn, payloads)
+      if payloads.first['at']
+        conn.zadd('schedule'.freeze, payloads.map do |hash|
+          at = hash.delete('at'.freeze).to_s
+          [at, Sidekiq.dump_json(hash)]
+        end)
+      else
+        q = payloads.first['queue']
+        now = Time.now.to_f
+        to_push = payloads.map do |entry|
+          entry['enqueued_at'.freeze] = now
+          Sidekiq.dump_json(entry)
         end
+        conn.sadd('queues'.freeze, q)
+        conn.lpush("queue:#{q}", to_push)
       end
+    end
 
-      def normalize_item(item)
-        raise(ArgumentError, "Message must be a Hash of the form: { 'class' => SomeWorker, 'args' => ['bob', 1, :foo => 'bar'] }") unless item.is_a?(Hash)
-        raise(ArgumentError, "Message must include a class and set of arguments: #{item.inspect}") if !item['class'] || !item['args']
-        raise(ArgumentError, "Message args must be an Array") unless item['args'].is_a?(Array)
-        raise(ArgumentError, "Message class must be either a Class or String representation of the class name") unless item['class'].is_a?(Class) || item['class'].is_a?(String)
-
-        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')
-          normalized_item = item['class'].get_sidekiq_options.merge(item)
-          normalized_item['class'] = normalized_item['class'].to_s
-        else
-          normalized_item = Sidekiq.default_worker_options.merge(item)
-        end
+    def process_single(worker_class, item)
+      queue = item['queue']
 
-        normalized_item['jid'] ||= SecureRandom.hex(12)
-        normalized_item['enqueued_at'] ||= Time.now.to_f
-        normalized_item
+      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