sidekiq 4.2.10 → 5.0.0

data/lib/sidekiq/job_retry.rb

@@ -0,0 +1,235 @@
+require 'sidekiq/scheduled'
+require 'sidekiq/api'
+
+module Sidekiq
+  ##
+  # Automatically retry jobs that fail in Sidekiq.
+  # Sidekiq's retry support assumes a typical development lifecycle:
+  #
+  #   0. Push some code changes with a bug in it.
+  #   1. Bug causes job processing to fail, Sidekiq's middleware captures
+  #      the job and pushes it onto a retry queue.
+  #   2. Sidekiq retries jobs in the retry queue multiple times with
+  #      an exponential delay, the job continues to fail.
+  #   3. After a few days, a developer deploys a fix. The job is
+  #      reprocessed successfully.
+  #   4. Once retries are exhausted, Sidekiq will give up and move the
+  #      job to the Dead Job Queue (aka morgue) where it must be dealt with
+  #      manually in the Web UI.
+  #   5. After 6 months on the DJQ, Sidekiq will discard the job.
+  #
+  # A job looks like:
+  #
+  #     { 'class' => 'HardWorker', 'args' => [1, 2, 'foo'], 'retry' => true }
+  #
+  # The 'retry' option also accepts a number (in place of 'true'):
+  #
+  #     { 'class' => 'HardWorker', 'args' => [1, 2, 'foo'], 'retry' => 5 }
+  #
+  # The job will be retried this number of times before giving up. (If simply
+  # 'true', Sidekiq retries 25 times)
+  #
+  # We'll add a bit more data to the job to support retries:
+  #
+  #  * 'queue' - the queue to use
+  #  * 'retry_count' - number of times we've retried so far.
+  #  * 'error_message' - the message from the exception
+  #  * 'error_class' - the exception class
+  #  * 'failed_at' - the first time it failed
+  #  * 'retried_at' - the last time it was retried
+  #  * 'backtrace' - the number of lines of error backtrace to store
+  #
+  # We don't store the backtrace by default as that can add a lot of overhead
+  # to the job and everyone is using an error service, right?
+  #
+  # The default number of retries is 25 which works out to about 3 weeks
+  # You can change the default maximum number of retries in your initializer:
+  #
+  #   Sidekiq.options[:max_retries] = 7
+  #
+  # or limit the number of retries for a particular worker with:
+  #
+  #    class MyWorker
+  #      include Sidekiq::Worker
+  #      sidekiq_options :retry => 10
+  #    end
+  #
+  class JobRetry
+    class Skip < ::RuntimeError; end
+
+    include Sidekiq::Util
+
+    DEFAULT_MAX_RETRY_ATTEMPTS = 25
+
+    def initialize(options = {})
+      @max_retries = Sidekiq.options.merge(options).fetch(:max_retries, DEFAULT_MAX_RETRY_ATTEMPTS)
+    end
+
+    # The global retry handler requires only the barest of data.
+    # We want to be able to retry as much as possible so we don't
+    # require the worker to be instantiated.
+    def global(msg, queue)
+      yield
+    rescue Skip => ex
+      raise ex
+    rescue Sidekiq::Shutdown => ey
+      # ignore, will be pushed back onto queue during hard_shutdown
+      raise ey
+    rescue Exception => e
+      # ignore, will be pushed back onto queue during hard_shutdown
+      raise Sidekiq::Shutdown if exception_caused_by_shutdown?(e)
+
+      raise e unless msg['retry']
+      attempt_retry(nil, msg, queue, e)
+      raise e
+    end
+
+
+    # The local retry support means that any errors that occur within
+    # this block can be associated with the given worker instance.
+    # This is required to support the `sidekiq_retries_exhausted` block.
+    #
+    # Note that any exception from the block is wrapped in the Skip
+    # exception so the global block does not reprocess the error.  The
+    # Skip exception is unwrapped within Sidekiq::Processor#process before
+    # calling the handle_exception handlers.
+    def local(worker, msg, queue)
+      yield
+    rescue Skip => ex
+      raise ex
+    rescue Sidekiq::Shutdown => ey
+      # ignore, will be pushed back onto queue during hard_shutdown
+      raise ey
+    rescue Exception => e
+      # ignore, will be pushed back onto queue during hard_shutdown
+      raise Sidekiq::Shutdown if exception_caused_by_shutdown?(e)
+
+      if msg['retry'] == nil
+        msg['retry'] = worker.class.get_sidekiq_options['retry']
+      end
+
+      raise e unless msg['retry']
+      attempt_retry(worker, msg, queue, e)
+      # We've handled this error associated with this job, don't
+      # need to handle it at the global level
+      raise Skip
+    end
+
+    private
+
+    # Note that +worker+ can be nil here if an error is raised before we can
+    # instantiate the worker instance.  All access must be guarded and
+    # best effort.
+    def attempt_retry(worker, msg, queue, exception)
+      max_retry_attempts = retry_attempts_from(msg['retry'], @max_retries)
+
+      msg['queue'] = if msg['retry_queue']
+        msg['retry_queue']
+      else
+        queue
+      end
+
+      # App code can stuff all sorts of crazy binary data into the error message
+      # that won't convert to JSON.
+      m = exception.message.to_s[0, 10_000]
+      if m.respond_to?(:scrub!)
+        m.force_encoding("utf-8")
+        m.scrub!
+      end
+
+      msg['error_message'] = m
+      msg['error_class'] = exception.class.name
+      count = if msg['retry_count']
+        msg['retried_at'] = Time.now.to_f
+        msg['retry_count'] += 1
+      else
+        msg['failed_at'] = Time.now.to_f
+        msg['retry_count'] = 0
+      end
+
+      if msg['backtrace'] == true
+        msg['error_backtrace'] = exception.backtrace
+      elsif !msg['backtrace']
+        # do nothing
+      elsif msg['backtrace'].to_i != 0
+        msg['error_backtrace'] = exception.backtrace[0...msg['backtrace'].to_i]
+      end
+
+      if count < max_retry_attempts
+        delay = delay_for(worker, count, exception)
+        logger.debug { "Failure! Retry #{count} in #{delay} seconds" }
+        retry_at = Time.now.to_f + delay
+        payload = Sidekiq.dump_json(msg)
+        Sidekiq.redis do |conn|
+          conn.zadd('retry', retry_at.to_s, payload)
+        end
+      else
+        # Goodbye dear message, you (re)tried your best I'm sure.
+        retries_exhausted(worker, msg, exception)
+      end
+    end
+
+    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.call(msg, exception) if block
+      rescue => e
+        handle_exception(e, { context: "Error calling retries_exhausted for #{msg['class']}", job: msg })
+      end
+
+      send_to_morgue(msg) unless msg['dead'] == false
+    end
+
+    def send_to_morgue(msg)
+      Sidekiq.logger.info { "Adding dead #{msg['class']} job #{msg['jid']}" }
+      payload = Sidekiq.dump_json(msg)
+      now = Time.now.to_f
+      Sidekiq.redis do |conn|
+        conn.multi do
+          conn.zadd('dead', now, payload)
+          conn.zremrangebyscore('dead', '-inf', now - DeadSet.timeout)
+          conn.zremrangebyrank('dead', 0, -DeadSet.max_jobs)
+        end
+      end
+    end
+
+    def retry_attempts_from(msg_retry, default)
+      if msg_retry.is_a?(Integer)
+        msg_retry
+      else
+        default
+      end
+    end
+
+    def delay_for(worker, count, exception)
+      worker && worker.sidekiq_retry_in_block? && retry_in(worker, count, exception) || seconds_to_delay(count)
+    end
+
+    # delayed_job uses the same basic formula
+    def seconds_to_delay(count)
+      (count ** 4) + 15 + (rand(30)*(count+1))
+    end
+
+    def retry_in(worker, count, exception)
+      begin
+        worker.sidekiq_retry_in_block.call(count, exception).to_i
+      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
+      end
+    end
+
+    def exception_caused_by_shutdown?(e, checked_causes = [])
+      return false unless e.cause
+
+      # Handle circular causes
+      checked_causes << e.object_id
+      return false if checked_causes.include?(e.cause.object_id)
+
+      e.cause.instance_of?(Sidekiq::Shutdown) ||
+        exception_caused_by_shutdown?(e.cause, checked_causes)
+    end
+
+  end
+end

data/lib/sidekiq/launcher.rb

@@ -61,8 +61,6 @@ module Sidekiq
 
     private unless $TESTING
 
-    JVM_RESERVED_SIGNALS = ['USR1', 'USR2'] # Don't Process#kill if we get these signals via the API
-
     def heartbeat
       results = Sidekiq::CLI::PROCTITLES.map {|x| x.(self, to_data) }
       results.compact!
@@ -110,11 +108,7 @@ module Sidekiq
 
         return unless msg
 
-        if JVM_RESERVED_SIGNALS.include?(msg)
-          Sidekiq::CLI.instance.handle_signal(msg)
-        else
-          ::Process.kill(msg, $$)
-        end
+        ::Process.kill(msg, $$)
       rescue => e
         # ignore all redis/network issues
         logger.error("heartbeat: #{e.message}")

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

@@ -2,6 +2,15 @@ module Sidekiq
   module Middleware
     module Server
       class ActiveRecord
+
+        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
+            raise ArgumentError, "Rails 5 no longer needs or uses the ActiveRecord middleware."
+          end
+        end
+
         def call(*args)
           yield
         ensure

data/lib/sidekiq/processor.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 require 'sidekiq/util'
 require 'sidekiq/fetch'
+require 'sidekiq/job_logger'
+require 'sidekiq/job_retry'
 require 'thread'
 require 'concurrent/map'
 require 'concurrent/atomic/atomic_fixnum'
@@ -37,7 +39,8 @@ module Sidekiq
       @thread = nil
       @strategy = (mgr.options[:fetch] || Sidekiq::BasicFetch).new(mgr.options)
       @reloader = Sidekiq.options[:reloader]
-      @executor = Sidekiq.options[:executor]
+      @logging = Sidekiq::JobLogger.new
+      @retrier = Sidekiq::JobRetry.new
     end
 
     def terminate(wait=false)
@@ -116,32 +119,61 @@ module Sidekiq
       nil
     end
 
+    def dispatch(job_hash, queue)
+      # since middleware can mutate the job hash
+      # we clone here so we report the original
+      # job structure to the Web UI
+      pristine = cloned(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]
+      ctx = "#{klass} JID-#{job_hash['jid'.freeze]}#{" BID-#{job_hash['bid'.freeze]}" if job_hash['bid'.freeze]}"
+
+      Sidekiq::Logging.with_context(ctx) do
+        @retrier.global(job_hash, queue) do
+          @logging.call(job_hash, queue) do
+            stats(pristine, queue) do
+              # Rails 5 requires a Reloader to wrap code execution.  In order to
+              # constantize the worker and instantiate an instance, we have to call
+              # the Reloader.  It handles code loading, db connection management, etc.
+              # Effectively this block denotes a "unit of work" to Rails.
+              @reloader.call do
+                klass  = job_hash['class'.freeze].constantize
+                worker = klass.new
+                worker.jid = job_hash['jid'.freeze]
+                @retrier.local(worker, job_hash, queue) do
+                  yield worker
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
     def process(work)
       jobstr = work.job
       queue = work.queue_name
 
       ack = false
       begin
-        job_hash = Sidekiq.load_json(jobstr)
-        @reloader.call do
-          klass  = job_hash['class'.freeze].constantize
-          worker = klass.new
-          worker.jid = job_hash['jid'.freeze]
-
-          stats(worker, job_hash, queue) do
-            Sidekiq::Logging.with_context(log_context(job_hash)) do
-              ack = true
-              Sidekiq.server_middleware.invoke(worker, job_hash, queue) do
-                @executor.call do
-                  # Only ack if we either attempted to start this job or
-                  # successfully completed it. This prevents us from
-                  # losing jobs if a middleware raises an exception before yielding
-                  execute_job(worker, cloned(job_hash['args'.freeze]))
-                end
-              end
-            end
-          end
+        # Treat malformed JSON as a special case: job goes straight to the morgue.
+        job_hash = nil
+        begin
+          job_hash = Sidekiq.load_json(jobstr)
+        rescue => ex
+          handle_exception(ex, { :context => "Invalid JSON for job", :jobstr => jobstr })
+          send_to_morgue(jobstr)
           ack = true
+          raise
+        end
+
+        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]))
+          end
         end
       rescue Sidekiq::Shutdown
         # Had to force kill this job because it didn't finish
@@ -149,18 +181,23 @@ module Sidekiq
         # we didn't properly finish it.
         ack = false
       rescue Exception => ex
-        handle_exception(ex, { :context => "Job raised exception", :job => job_hash, :jobstr => jobstr })
-        raise
+        e = ex.is_a?(::Sidekiq::JobRetry::Skip) && ex.cause ? ex.cause : ex
+        handle_exception(e, { :context => "Job raised exception", :job => job_hash, :jobstr => jobstr })
+        raise e
       ensure
         work.acknowledge if ack
       end
     end
 
-    # If we're using a wrapper class, like ActiveJob, use the "wrapped"
-    # attribute to expose the underlying thing.
-    def log_context(item)
-      klass = item['wrapped'.freeze] || item['class'.freeze]
-      "#{klass} JID-#{item['jid'.freeze]}#{" BID-#{item['bid'.freeze]}" if item['bid'.freeze]}"
+    def send_to_morgue(msg)
+      now = Time.now.to_f
+      Sidekiq.redis do |conn|
+        conn.multi do
+          conn.zadd('dead', now, msg)
+          conn.zremrangebyscore('dead', '-inf', now - DeadSet.timeout)
+          conn.zremrangebyrank('dead', 0, -DeadSet.max_jobs)
+        end
+      end
     end
 
     def execute_job(worker, cloned_args)
@@ -175,9 +212,9 @@ module Sidekiq
     PROCESSED = Concurrent::AtomicFixnum.new
     FAILURE = Concurrent::AtomicFixnum.new
 
-    def stats(worker, job_hash, queue)
+    def stats(job_hash, queue)
       tid = thread_identity
-      WORKER_STATE[tid] = {:queue => queue, :payload => cloned(job_hash), :run_at => Time.now.to_i }
+      WORKER_STATE[tid] = {:queue => queue, :payload => job_hash, :run_at => Time.now.to_i }
 
       begin
         yield
@@ -193,8 +230,8 @@ module Sidekiq
     # Deep clone the arguments passed to the worker so that if
     # the job fails, what is pushed back onto Redis hasn't
     # been mutated by the worker.
-    def cloned(ary)
-      Marshal.load(Marshal.dump(ary))
+    def cloned(thing)
+      Marshal.load(Marshal.dump(thing))
     end
 
   end

data/lib/sidekiq/rails.rb

@@ -1,36 +1,5 @@
 # frozen_string_literal: true
 module Sidekiq
-  def self.hook_rails!
-    return if defined?(@delay_removed)
-
-    ActiveSupport.on_load(:active_record) do
-      include Sidekiq::Extensions::ActiveRecord
-    end
-
-    ActiveSupport.on_load(:action_mailer) do
-      extend Sidekiq::Extensions::ActionMailer
-    end
-
-    Module.__send__(:include, Sidekiq::Extensions::Klass)
-  end
-
-  # Removes the generic aliases which MAY clash with names of already
-  #  created methods by other applications. The methods `sidekiq_delay`,
-  #  `sidekiq_delay_for` and `sidekiq_delay_until` can be used instead.
-  def self.remove_delay!
-    @delay_removed = true
-
-    [Extensions::ActiveRecord,
-     Extensions::ActionMailer,
-     Extensions::Klass].each do |mod|
-      mod.module_eval do
-        remove_method :delay if respond_to?(:delay)
-        remove_method :delay_for if respond_to?(:delay_for)
-        remove_method :delay_until if respond_to?(:delay_until)
-      end
-    end
-  end
-
   class Rails < ::Rails::Engine
     # We need to setup this up before any application configuration which might
     # change Sidekiq middleware.
@@ -48,10 +17,6 @@ module Sidekiq
       end
     end
 
-    initializer 'sidekiq' do
-      Sidekiq.hook_rails!
-    end
-
     config.after_initialize do
       # This hook happens after all initializers are run, just before returning
       # from config/environment.rb back to sidekiq/cli.rb.
@@ -62,40 +27,12 @@ module Sidekiq
       #
       Sidekiq.configure_server do |_|
         if ::Rails::VERSION::MAJOR >= 5
-          # The reloader also takes care of ActiveRecord but is incompatible with
-          # the ActiveRecord middleware so make sure it's not in the chain already.
-          if defined?(Sidekiq::Middleware::Server::ActiveRecord) && Sidekiq.server_middleware.exists?(Sidekiq::Middleware::Server::ActiveRecord)
-            raise ArgumentError, "You are using the Sidekiq ActiveRecord middleware and the new Rails 5 reloader which are incompatible. Please remove the ActiveRecord middleware from your Sidekiq middleware configuration."
-          elsif ::Rails.application.config.cache_classes
-            # The reloader API has proven to be troublesome under load in production.
-            # We won't use it at all when classes are cached, see #3154
-            Sidekiq.logger.debug { "Autoload disabled in #{::Rails.env}, Sidekiq will not reload changed classes" }
-            Sidekiq.options[:executor] = Sidekiq::Rails::Executor.new
-          else
-            Sidekiq.logger.debug { "Enabling Rails 5+ live code reloading, so hot!" }
-            Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
-            Psych::Visitors::ToRuby.prepend(Sidekiq::Rails::PsychAutoload)
-          end
+          Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
+          Psych::Visitors::ToRuby.prepend(Sidekiq::Rails::PsychAutoload)
         end
       end
     end
 
-    class Executor
-      def initialize(app = ::Rails.application)
-        @app = app
-      end
-
-      def call
-        @app.executor.wrap do
-          yield
-        end
-      end
-
-      def inspect
-        "#<Sidekiq::Rails::Executor @app=#{@app.class.name}>"
-      end
-    end
-
     class Reloader
       def initialize(app = ::Rails.application)
         @app = app

data/lib/sidekiq/redis_connection.rb

@@ -67,7 +67,7 @@ module Sidekiq
           opts.delete(:network_timeout)
         end
 
-        opts[:driver] ||= 'ruby'
+        opts[:driver] ||= 'ruby'.freeze
 
         # Issue #3303, redis-rb will silently retry an operation.
         # This can lead to duplicate jobs if Sidekiq::Client's LPUSH

data/lib/sidekiq/testing.rb

@@ -317,7 +317,7 @@ module Sidekiq
   end
 end
 
-if defined?(::Rails) && !Rails.env.test?
+if defined?(::Rails) && Rails.respond_to?(:env) && !Rails.env.test?
   puts("**************************************************")
   puts("⛔️ WARNING: Sidekiq testing API enabled, but this is not the test environment.  Your jobs will not go to Redis.")
   puts("**************************************************")

data/lib/sidekiq/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Sidekiq
-  VERSION = "4.2.10"
+  VERSION = "5.0.0"
 end

data/lib/sidekiq/web/action.rb

@@ -39,10 +39,6 @@ module Sidekiq
       env[RACK_SESSION]
     end
 
-    def content_type(type)
-      @type = type
-    end
-
     def erb(content, options = {})
       if content.kind_of? Symbol
         unless respond_to?(:"_erb_#{content}")

data/lib/sidekiq/web/application.rb

@@ -274,19 +274,14 @@ module Sidekiq
       resp = case resp
       when Array
         resp
-      when Integer
-        [resp, {}, []]
       else
-        type_header = case action.type
-        when :json
-          { "Content-Type" => "application/json", "Cache-Control" => "no-cache" }
-        when String
-          { "Content-Type" => (action.type || "text/html"), "Cache-Control" => "no-cache" }
-        else
-          { "Content-Type" => "text/html", "Cache-Control" => "no-cache" }
-        end
+        headers = {
+          "Content-Type" => "text/html",
+          "Cache-Control" => "no-cache",
+          "Content-Language" => action.locale,
+        }
 
-        [200, type_header, [resp]]
+        [200, headers, [resp]]
       end
 
       resp[1] = resp[1].dup

data/lib/sidekiq/web/helpers.rb

@@ -65,6 +65,14 @@ module Sidekiq
       end
     end
 
+    def text_direction
+      get_locale['TextDirection'] || 'ltr'
+    end
+
+    def rtl?
+      text_direction == 'rtl'
+    end
+
     # Given a browser request Accept-Language header like
     # "fr-FR,fr;q=0.8,en-US;q=0.6,en;q=0.4,ru;q=0.2", this function
     # will return "fr" since that's the first code with a matching
@@ -144,7 +152,7 @@ module Sidekiq
 
     def relative_time(time)
       stamp = time.getutc.iso8601
-      %{<time title="#{stamp}" datetime="#{stamp}">#{time}</time>}
+      %{<time class="ltr" dir="ltr" title="#{stamp}" datetime="#{stamp}">#{time}</time>}
     end
 
     def job_params(job, score)

data/lib/sidekiq/worker.rb

@@ -4,6 +4,7 @@ require 'sidekiq/core_ext'
 
 module Sidekiq
 
+
   ##
   # Include this module in your worker class and you can easily create
   # asynchronous jobs:
@@ -37,6 +38,34 @@ module Sidekiq
       Sidekiq.logger
     end
 
+    # This helper class encapsulates the set options for `set`, e.g.
+    #
+    #     SomeWorker.set(queue: 'foo').perform_async(....)
+    #
+    class Setter
+      def initialize(opts)
+        @opts = opts
+      end
+
+      def perform_async(*args)
+        @opts['class'.freeze].client_push(@opts.merge!('args'.freeze => args))
+      end
+
+      # +interval+ must be a timestamp, numeric or something that acts
+      #   numeric (like an activesupport time interval).
+      def perform_in(interval, *args)
+        int = interval.to_f
+        now = Time.now.to_f
+        ts = (int < 1_000_000_000 ? now + int : int)
+
+        @opts.merge! 'args'.freeze => args, 'at'.freeze => ts
+        # Optimization to enqueue something now that is scheduled to go out now or in the past
+        @opts.delete('at'.freeze) if ts <= now
+        @opts['class'.freeze].client_push(@opts)
+      end
+      alias_method :perform_at, :perform_in
+    end
+
     module ClassMethods
 
       def delay(*args)
@@ -52,12 +81,11 @@ module Sidekiq
       end
 
       def set(options)
-        Thread.current[:sidekiq_worker_set] = options
-        self
+        Setter.new(options.merge!('class'.freeze => self))
       end
 
       def perform_async(*args)
-        client_push('class' => self, 'args' => args)
+        client_push('class'.freeze => self, 'args'.freeze => args)
       end
 
       # +interval+ must be a timestamp, numeric or something that acts
@@ -67,7 +95,7 @@ module Sidekiq
         now = Time.now.to_f
         ts = (int < 1_000_000_000 ? now + int : int)
 
-        item = { 'class' => self, 'args' => args, 'at' => ts }
+        item = { 'class'.freeze => self, 'args'.freeze => args, 'at'.freeze => ts }
 
         # Optimization to enqueue something now that is scheduled to go out now or in the past
         item.delete('at'.freeze) if ts <= now
@@ -106,13 +134,8 @@ module Sidekiq
       end
 
       def client_push(item) # :nodoc:
-        pool = Thread.current[:sidekiq_via_pool] || get_sidekiq_options['pool'] || Sidekiq.redis_pool
-        hash = if Thread.current[:sidekiq_worker_set]
-          x, Thread.current[:sidekiq_worker_set] = Thread.current[:sidekiq_worker_set], nil
-          x.stringify_keys.merge(item.stringify_keys)
-        else
-          item.stringify_keys
-        end
+        pool = Thread.current[:sidekiq_via_pool] || get_sidekiq_options['pool'.freeze] || Sidekiq.redis_pool
+        hash = item.stringify_keys
         Sidekiq::Client.new(pool).push(hash)
       end