sidekiq 5.0.5 → 5.2.1

data/lib/sidekiq/cli.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 $stdout.sync = true
 
@@ -17,7 +16,7 @@ module Sidekiq
     include Singleton unless $TESTING
 
     PROCTITLES = [
-      proc { 'sidekiq'.freeze },
+      proc { 'sidekiq' },
       proc { Sidekiq::VERSION },
       proc { |me, data| data['tag'] },
       proc { |me, data| "[#{Processor::WORKER_STATE.size} of #{data['concurrency']} busy]" },
@@ -65,7 +64,7 @@ module Sidekiq
       sigs.each do |sig|
         begin
           trap sig do
-            self_write.puts(sig)
+            self_write.write("#{sig}\n")
           end
         rescue ArgumentError
           puts "Signal #{sig} not supported"
@@ -81,6 +80,12 @@ module Sidekiq
       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'
 
+      # Since the user can pass us a connection pool explicitly in the initializer, we
+      # need to verify the size is large enough or else Sidekiq's performance is dramatically slowed.
+      cursize = Sidekiq.redis_pool.size
+      needed = Sidekiq.options[:concurrency] + 2
+      raise "Your pool of #{cursize} Redis connections is too small, please increase the size to at least #{needed}" if cursize < needed
+
       # cache process identity
       Sidekiq.options[:identity] = identity
 
@@ -89,7 +94,7 @@ module Sidekiq
 
       # 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)
+      fire_event(:startup, reverse: false, reraise: true)
 
       logger.debug { "Client Middleware: #{Sidekiq.client_middleware.map(&:klass).join(', ')}" }
       logger.debug { "Server Middleware: #{Sidekiq.server_middleware.map(&:klass).join(', ')}" }
@@ -135,37 +140,45 @@ module Sidekiq
 }
     end
 
-    def handle_signal(sig)
-      Sidekiq.logger.debug "Got #{sig} signal"
-      case sig
-      when 'INT'
-        # Handle Ctrl-C in JRuby like MRI
-        # http://jira.codehaus.org/browse/JRUBY-4637
-        raise Interrupt
-      when 'TERM'
-        # Heroku sends TERM and then waits 10 seconds for process to exit.
-        raise Interrupt
-      when 'USR1'
+    SIGNAL_HANDLERS = {
+      # Ctrl-C in terminal
+      'INT' => ->(cli) { raise Interrupt },
+      # TERM is the signal that Sidekiq must exit.
+      # Heroku sends TERM and then waits 30 seconds for process to exit.
+      'TERM' => ->(cli) { raise Interrupt },
+      'USR1' => ->(cli) {
         Sidekiq.logger.info "Received USR1, no longer accepting new work"
-        launcher.quiet
-      when 'TSTP'
-        # USR1 is not available on JVM, allow TSTP as an alternate signal
+        cli.launcher.quiet
+      },
+      'TSTP' => ->(cli) {
         Sidekiq.logger.info "Received TSTP, no longer accepting new work"
-        launcher.quiet
-      when 'USR2'
+        cli.launcher.quiet
+      },
+      'USR2' => ->(cli) {
         if Sidekiq.options[:logfile]
           Sidekiq.logger.info "Received USR2, reopening log file"
           Sidekiq::Logging.reopen_logs
         end
-      when 'TTIN'
+      },
+      'TTIN' => ->(cli) {
         Thread.list.each do |thread|
-          Sidekiq.logger.warn "Thread TID-#{thread.object_id.to_s(36)} #{thread['sidekiq_label']}"
+          Sidekiq.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread['sidekiq_label']}"
           if thread.backtrace
             Sidekiq.logger.warn thread.backtrace.join("\n")
           else
             Sidekiq.logger.warn "<no backtrace available>"
           end
         end
+      },
+    }
+
+    def handle_signal(sig)
+      Sidekiq.logger.debug "Got #{sig} signal"
+      handy = SIGNAL_HANDLERS[sig]
+      if handy
+        handy.call(self)
+      else
+        Sidekiq.logger.info { "No signal handler for #{sig}" }
       end
     end
 
@@ -214,6 +227,14 @@ module Sidekiq
       @environment = cli_env || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
     end
 
+    def symbolize_keys_deep!(hash)
+      hash.keys.each do |k|
+        symkey = k.respond_to?(:to_sym) ? k.to_sym : k
+        hash[symkey] = hash.delete k
+        symbolize_keys_deep! hash[symkey] if hash[symkey].kind_of? Hash
+      end
+    end
+
     alias_method :die, :exit
     alias_method :☠, :exit
 
@@ -282,7 +303,7 @@ module Sidekiq
       if !File.exist?(options[:require]) ||
          (File.directory?(options[:require]) && !File.exist?("#{options[:require]}/config/application.rb"))
         logger.info "=================================================================="
-        logger.info "  Please point sidekiq to a Rails 3/4 application or a Ruby file  "
+        logger.info "  Please point sidekiq to a Rails 4/5 application or a Ruby file  "
         logger.info "  to load your worker classes with -r [DIR|FILE]."
         logger.info "=================================================================="
         logger.info @parser
@@ -314,6 +335,8 @@ module Sidekiq
           opts[:tag] = arg
         end
 
+        # this index remains here for backwards compatibility but none of the Sidekiq
+        # family use this value anymore.  it was used by Pro's original reliable_fetch.
         o.on '-i', '--index INT', "unique process index on this machine" do |arg|
           opts[:index] = Integer(arg.match(/\d+/)[0])
         end
@@ -386,7 +409,14 @@ module Sidekiq
       opts = {}
       if File.exist?(cfile)
         opts = YAML.load(ERB.new(IO.read(cfile)).result) || opts
-        opts = opts.merge(opts.delete(environment) || {})
+
+        if opts.respond_to? :deep_symbolize_keys!
+          opts.deep_symbolize_keys!
+        else
+          symbolize_keys_deep!(opts)
+        end
+
+        opts = opts.merge(opts.delete(environment.to_sym) || {})
         parse_queues(opts, opts.delete(:queues) || [])
       else
         # allow a non-existent config file so Sidekiq

data/lib/sidekiq/client.rb

@@ -68,18 +68,19 @@ module Sidekiq
     #
     def push(item)
       normed = normalize_item(item)
-      payload = process_single(item['class'.freeze], normed)
+      payload = process_single(item['class'], normed)
 
       if payload
         raw_push([payload])
-        payload['jid'.freeze]
+        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
@@ -89,19 +90,19 @@ 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'.freeze].first
+      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'.freeze].map do |args|
-        copy = normed.merge('args'.freeze => args, 'jid'.freeze => SecureRandom.hex(12), 'enqueued_at'.freeze => Time.now.to_f)
-        result = process_single(items['class'.freeze], copy)
+      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'.freeze] }
+      payloads.collect { |payload| payload['jid'] }
     end
 
     # Allows sharding of jobs across any number of Redis instances.  All jobs
@@ -119,11 +120,10 @@ 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
@@ -145,14 +145,14 @@ module Sidekiq
       # Messages are enqueued to the 'default' queue.
       #
       def enqueue(klass, *args)
-        klass.client_push('class'.freeze => klass, 'args'.freeze => 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'.freeze => queue, 'class'.freeze => klass, 'args'.freeze => args)
+        klass.client_push('queue' => queue, 'class' => klass, 'args' => args)
       end
 
       # Example usage:
@@ -163,8 +163,8 @@ module Sidekiq
         now = Time.now.to_f
         ts = (int < 1_000_000_000 ? now + int : int)
 
-        item = { 'class'.freeze => klass, 'args'.freeze => args, 'at'.freeze => ts, 'queue'.freeze => 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
@@ -189,25 +189,25 @@ module Sidekiq
     end
 
     def atomic_push(conn, payloads)
-      if payloads.first['at'.freeze]
-        conn.zadd('schedule'.freeze, payloads.map do |hash|
-          at = hash.delete('at'.freeze).to_s
+      if payloads.first['at']
+        conn.zadd('schedule', payloads.map do |hash|
+          at = hash.delete('at').to_s
           [at, Sidekiq.dump_json(hash)]
         end)
       else
-        q = payloads.first['queue'.freeze]
+        q = payloads.first['queue']
         now = Time.now.to_f
         to_push = payloads.map do |entry|
-          entry['enqueued_at'.freeze] = now
+          entry['enqueued_at'] = now
           Sidekiq.dump_json(entry)
         end
-        conn.sadd('queues'.freeze, q)
+        conn.sadd('queues', q)
         conn.lpush("queue:#{q}", to_push)
       end
     end
 
     def process_single(worker_class, item)
-      queue = item['queue'.freeze]
+      queue = item['queue']
 
       middleware.invoke(worker_class, item, queue, @redis_pool) do
         item
@@ -215,25 +215,25 @@ module Sidekiq
     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 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') && item.has_key?('args')
       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, "Job 'at' must be a Numeric timestamp") if item.has_key?('at'.freeze) && !item['at'].is_a?(Numeric)
+      raise(ArgumentError, "Job class must be either a Class or String representation of the class name") unless item['class'].is_a?(Class) || item['class'].is_a?(String)
+      raise(ArgumentError, "Job 'at' must be a Numeric timestamp") if item.has_key?('at') && !item['at'].is_a?(Numeric)
       #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])
+      normalized_hash(item['class'])
         .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['class'] = item['class'].to_s
+      item['queue'] = item['queue'].to_s
+      item['jid'] ||= SecureRandom.hex(12)
+      item['created_at'] ||= 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)
+        raise(ArgumentError, "Message must include a Sidekiq::Worker class, not class name: #{item_class.ancestors.inspect}") if !item_class.respond_to?('get_sidekiq_options')
         item_class.get_sidekiq_options
       else
         Sidekiq.default_worker_options

data/lib/sidekiq/delay.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Sidekiq
   module Extensions
 

data/lib/sidekiq/exception_handler.rb

@@ -7,11 +7,10 @@ module Sidekiq
     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?
+        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
 
@@ -26,6 +25,5 @@ module Sidekiq
         end
       end
     end
-
   end
 end

data/lib/sidekiq/fetch.rb

@@ -13,7 +13,7 @@ module Sidekiq
       end
 
       def queue_name
-        queue.sub(/.*queue:/, ''.freeze)
+        queue.sub(/.*queue:/, '')
       end
 
       def requeue

data/lib/sidekiq/job_logger.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
 module Sidekiq
   class JobLogger
 
     def call(item, queue)
       start = Time.now
-      logger.info("start".freeze)
+      logger.info("start")
       yield
       logger.info("done: #{elapsed(start)} sec")
     rescue Exception

data/lib/sidekiq/job_retry.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'sidekiq/scheduled'
 require 'sidekiq/api'
 
@@ -172,10 +173,18 @@ module Sidekiq
     def retries_exhausted(worker, msg, exception)
       logger.debug { "Retries exhausted for job" }
       begin
-        block = worker && worker.sidekiq_retries_exhausted_block || Sidekiq.default_retries_exhausted
+        block = worker && worker.sidekiq_retries_exhausted_block
         block.call(msg, exception) if block
       rescue => e
-        handle_exception(e, { context: "Error calling retries_exhausted for #{msg['class']}", job: msg })
+        handle_exception(e, { context: "Error calling retries_exhausted", job: msg })
+      end
+
+      Sidekiq.death_handlers.each do |handler|
+        begin
+          handler.call(msg, exception)
+        rescue => e
+          handle_exception(e, { context: "Error calling death handler", job: msg })
+        end
       end
 
       send_to_morgue(msg) unless msg['dead'] == false
@@ -184,7 +193,7 @@ module Sidekiq
     def send_to_morgue(msg)
       Sidekiq.logger.info { "Adding dead #{msg['class']} job #{msg['jid']}" }
       payload = Sidekiq.dump_json(msg)
-      DeadSet.new.kill(payload)
+      DeadSet.new.kill(payload, notify_failure: false)
     end
 
     def retry_attempts_from(msg_retry, default)
@@ -196,7 +205,11 @@ module Sidekiq
     end
 
     def delay_for(worker, count, exception)
-      worker && worker.sidekiq_retry_in_block && retry_in(worker, count, exception) || seconds_to_delay(count)
+      if worker && worker.sidekiq_retry_in_block
+        custom_retry_in = retry_in(worker, count, exception).to_i
+        return custom_retry_in if custom_retry_in > 0
+      end
+      seconds_to_delay(count)
     end
 
     # delayed_job uses the same basic formula
@@ -206,7 +219,7 @@ module Sidekiq
 
     def retry_in(worker, count, exception)
       begin
-        worker.sidekiq_retry_in_block.call(count, exception).to_i
+        worker.sidekiq_retry_in_block.call(count, exception)
       rescue Exception => e
         handle_exception(e, { context: "Failure scheduling retry using the defined `sidekiq_retry_in` in #{worker.class.name}, falling back to default" })
         nil

data/lib/sidekiq/launcher.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 require 'sidekiq/manager'
 require 'sidekiq/fetch'
@@ -14,6 +13,8 @@ module Sidekiq
 
     attr_accessor :manager, :poller, :fetcher
 
+    STATS_TTL = 5*365*24*60*60
+
     def initialize(options)
       @manager = Sidekiq::Manager.new(options)
       @poller = Sidekiq::Scheduled::Poller.new
@@ -73,19 +74,24 @@ module Sidekiq
       key = identity
       fails = procd = 0
       begin
-        Processor::FAILURE.update {|curr| fails = curr; 0 }
-        Processor::PROCESSED.update {|curr| procd = curr; 0 }
+        fails = Processor::FAILURE.reset
+        procd = Processor::PROCESSED.reset
+        curstate = Processor::WORKER_STATE.dup
 
-        workers_key = "#{key}:workers".freeze
-        nowdate = Time.now.utc.strftime("%Y-%m-%d".freeze)
+        workers_key = "#{key}:workers"
+        nowdate = Time.now.utc.strftime("%Y-%m-%d")
         Sidekiq.redis do |conn|
           conn.multi do
-            conn.incrby("stat:processed".freeze, procd)
+            conn.incrby("stat:processed", procd)
             conn.incrby("stat:processed:#{nowdate}", procd)
-            conn.incrby("stat:failed".freeze, fails)
+            conn.expire("stat:processed:#{nowdate}", STATS_TTL)
+
+            conn.incrby("stat:failed", fails)
             conn.incrby("stat:failed:#{nowdate}", fails)
+            conn.expire("stat:failed:#{nowdate}", STATS_TTL)
+
             conn.del(workers_key)
-            Processor::WORKER_STATE.each_pair do |tid, hash|
+            curstate.each_pair do |tid, hash|
               conn.hset(workers_key, tid, Sidekiq.dump_json(hash))
             end
             conn.expire(workers_key, 60)
@@ -97,7 +103,7 @@ module Sidekiq
           conn.multi do
             conn.sadd('processes', key)
             conn.exists(key)
-            conn.hmset(key, 'info', to_json, 'busy', Processor::WORKER_STATE.size, 'beat', Time.now.to_f, 'quiet', @done)
+            conn.hmset(key, 'info', to_json, 'busy', curstate.size, 'beat', Time.now.to_f, 'quiet', @done)
             conn.expire(key, 60)
             conn.rpop("#{key}-signals")
           end
@@ -113,8 +119,8 @@ module Sidekiq
         # ignore all redis/network issues
         logger.error("heartbeat: #{e.message}")
         # don't lose the counts if there was a network issue
-        Processor::PROCESSED.increment(procd)
-        Processor::FAILURE.increment(fails)
+        Processor::PROCESSED.incr(procd)
+        Processor::FAILURE.incr(fails)
       end
     end
 

data/lib/sidekiq/logging.rb

@@ -11,7 +11,7 @@ module Sidekiq
 
       # Provide a call() method that returns the formatted message.
       def call(severity, time, program_name, message)
-        "#{time.utc.iso8601(3)} #{::Process.pid} TID-#{Thread.current.object_id.to_s(36)}#{context} #{severity}: #{message}\n"
+        "#{time.utc.iso8601(3)} #{::Process.pid} TID-#{Sidekiq::Logging.tid}#{context} #{severity}: #{message}\n"
       end
 
       def context
@@ -22,16 +22,20 @@ module Sidekiq
 
     class WithoutTimestamp < Pretty
       def call(severity, time, program_name, message)
-        "#{::Process.pid} TID-#{Thread.current.object_id.to_s(36)}#{context} #{severity}: #{message}\n"
+        "#{::Process.pid} TID-#{Sidekiq::Logging.tid}#{context} #{severity}: #{message}\n"
       end
     end
 
+    def self.tid
+      Thread.current['sidekiq_tid'] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
+    end
+
     def self.job_hash_context(job_hash)
       # If we're using a wrapper class, like ActiveJob, use the "wrapped"
       # attribute to expose the underlying thing.
-      klass = job_hash['wrapped'.freeze] || job_hash["class".freeze]
-      bid = job_hash['bid'.freeze]
-      "#{klass} JID-#{job_hash['jid'.freeze]}#{" BID-#{bid}" if bid}"
+      klass = job_hash['wrapped'] || job_hash["class"]
+      bid = job_hash['bid']
+      "#{klass} JID-#{job_hash['jid']}#{" BID-#{bid}" if bid}"
     end
 
     def self.with_job_hash_context(job_hash, &block)

data/lib/sidekiq/manager.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 require 'sidekiq/util'
 require 'sidekiq/processor'
@@ -54,7 +53,7 @@ module Sidekiq
 
       logger.info { "Terminating quiet workers" }
       @workers.each { |x| x.terminate }
-      fire_event(:quiet, true)
+      fire_event(:quiet, reverse: true)
     end
 
     # hack for quicker development / testing environment #2774
@@ -62,7 +61,7 @@ module Sidekiq
 
     def stop(deadline)
       quiet
-      fire_event(:shutdown, true)
+      fire_event(:shutdown, reverse: true)
 
       # some of the shutdown events can be async,
       # we don't have any way to know when they're done but

data/lib/sidekiq/middleware/server/active_record.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Sidekiq
   module Middleware
     module Server
@@ -6,7 +7,7 @@ module Sidekiq
         def initialize
           # With Rails 5+ we must use the Reloader **always**.
           # The reloader handles code loading and db connection management.
-          if ::Rails::VERSION::MAJOR >= 5
+          if defined?(::Rails) && ::Rails::VERSION::MAJOR >= 5
             raise ArgumentError, "Rails 5 no longer needs or uses the ActiveRecord middleware."
           end
         end

data/lib/sidekiq/processor.rb

@@ -4,8 +4,6 @@ require 'sidekiq/fetch'
 require 'sidekiq/job_logger'
 require 'sidekiq/job_retry'
 require 'thread'
-require 'concurrent/map'
-require 'concurrent/atomic/atomic_fixnum'
 
 module Sidekiq
   ##
@@ -111,9 +109,7 @@ module Sidekiq
       if !@down
         @down = Time.now
         logger.error("Error fetching job: #{ex}")
-        ex.backtrace.each do |bt|
-          logger.error(bt)
-        end
+        handle_exception(ex)
       end
       sleep(1)
       nil
@@ -134,9 +130,9 @@ module Sidekiq
               # the Reloader.  It handles code loading, db connection management, etc.
               # Effectively this block denotes a "unit of work" to Rails.
               @reloader.call do
-                klass  = constantize(job_hash['class'.freeze])
+                klass  = constantize(job_hash['class'])
                 worker = klass.new
-                worker.jid = job_hash['jid'.freeze]
+                worker.jid = job_hash['jid']
                 @retrier.local(worker, pristine, queue) do
                   yield worker
                 end
@@ -159,7 +155,8 @@ module Sidekiq
           job_hash = Sidekiq.load_json(jobstr)
         rescue => ex
           handle_exception(ex, { :context => "Invalid JSON for job", :jobstr => jobstr })
-          DeadSet.new.kill(jobstr)
+          # we can't notify because the job isn't a valid hash payload.
+          DeadSet.new.kill(jobstr, notify_failure: false)
           ack = true
           raise
         end
@@ -167,7 +164,7 @@ module Sidekiq
         ack = true
         dispatch(job_hash, queue) do |worker|
           Sidekiq.server_middleware.invoke(worker, job_hash, queue) do
-            execute_job(worker, cloned(job_hash['args'.freeze]))
+            execute_job(worker, cloned(job_hash['args']))
           end
         end
       rescue Sidekiq::Shutdown
@@ -188,26 +185,42 @@ module Sidekiq
       worker.perform(*cloned_args)
     end
 
-    def thread_identity
-      @str ||= Thread.current.object_id.to_s(36)
+    # Ruby doesn't provide atomic counters out of the box so we'll
+    # implement something simple ourselves.
+    # https://bugs.ruby-lang.org/issues/14706
+    class Counter
+      def initialize
+        @value = 0
+        @lock = Mutex.new
+      end
+
+      def incr(amount=1)
+        @lock.synchronize { @value = @value + amount }
+      end
+
+      def reset
+        @lock.synchronize { val = @value; @value = 0; val }
+      end
     end
 
-    WORKER_STATE = Concurrent::Map.new
-    PROCESSED = Concurrent::AtomicFixnum.new
-    FAILURE = Concurrent::AtomicFixnum.new
+    PROCESSED = Counter.new
+    FAILURE = Counter.new
+    # This is mutable global state but because each thread is storing
+    # its own unique key/value, there's no thread-safety issue AFAIK.
+    WORKER_STATE = {}
 
     def stats(job_hash, queue)
-      tid = thread_identity
+      tid = Sidekiq::Logging.tid
       WORKER_STATE[tid] = {:queue => queue, :payload => job_hash, :run_at => Time.now.to_i }
 
       begin
         yield
       rescue Exception
-        FAILURE.increment
+        FAILURE.incr
         raise
       ensure
         WORKER_STATE.delete(tid)
-        PROCESSED.increment
+        PROCESSED.incr
       end
     end
 
@@ -223,7 +236,9 @@ module Sidekiq
       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)
+        # the false flag limits search for name to under the constant namespace
+        #   which mimics Rails' behaviour
+        constant.const_defined?(name, false) ? constant.const_get(name, false) : constant.const_missing(name)
       end
     end