sidekiq 3.5.4 → 7.2.0

data/lib/sidekiq/paginator.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Sidekiq
   module Paginator
-
-    def page(key, pageidx=1, page_size=25, opts=nil)
-      current_page = pageidx.to_i < 1 ? 1 : pageidx.to_i
+    def page(key, pageidx = 1, page_size = 25, opts = nil)
+      current_page = (pageidx.to_i < 1) ? 1 : pageidx.to_i
       pageidx = current_page - 1
       total_size = 0
       items = []
@@ -11,26 +12,31 @@ module Sidekiq
 
       Sidekiq.redis do |conn|
         type = conn.type(key)
+        rev = opts && opts[:reverse]
 
         case type
-        when 'zset'
-          rev = opts && opts[:reverse]
-          total_size, items = conn.multi do
-            conn.zcard(key)
+        when "zset"
+          total_size, items = conn.multi { |transaction|
+            transaction.zcard(key)
             if rev
-              conn.zrevrange(key, starting, ending, :with_scores => true)
+              transaction.zrange(key, starting, ending, "REV", "withscores")
             else
-              conn.zrange(key, starting, ending, :with_scores => true)
+              transaction.zrange(key, starting, ending, "withscores")
             end
-          end
+          }
           [current_page, total_size, items]
-        when 'list'
-          total_size, items = conn.multi do
-            conn.llen(key)
-            conn.lrange(key, starting, ending)
-          end
+        when "list"
+          total_size, items = conn.multi { |transaction|
+            transaction.llen(key)
+            if rev
+              transaction.lrange(key, -ending - 1, -starting - 1)
+            else
+              transaction.lrange(key, starting, ending)
+            end
+          }
+          items.reverse! if rev
           [current_page, total_size, items]
-        when 'none'
+        when "none"
           [1, 0, []]
         else
           raise "can't page a #{type}"
@@ -38,5 +44,12 @@ module Sidekiq
       end
     end
 
+    def page_items(items, pageidx = 1, page_size = 25)
+      current_page = (pageidx.to_i < 1) ? 1 : pageidx.to_i
+      pageidx = current_page - 1
+      starting = pageidx * page_size
+      items = items.to_a
+      [current_page, items.size, items[starting, page_size]]
+    end
   end
 end

data/lib/sidekiq/processor.rb

@@ -1,161 +1,281 @@
-require 'sidekiq/util'
-require 'sidekiq/actor'
+# frozen_string_literal: true
 
-require 'sidekiq/middleware/server/retry_jobs'
-require 'sidekiq/middleware/server/logging'
+require "sidekiq/fetch"
+require "sidekiq/job_logger"
+require "sidekiq/job_retry"
 
 module Sidekiq
   ##
-  # The Processor receives a message from the Manager and actually
-  # processes it.  It instantiates the worker, runs the middleware
-  # chain and then calls Sidekiq::Worker#perform.
+  # The Processor is a standalone thread which:
+  #
+  # 1. fetches a job from Redis
+  # 2. executes the job
+  #   a. instantiate the job class
+  #   b. run the middleware chain
+  #   c. call #perform
+  #
+  # A Processor can exit due to shutdown or due to
+  # an error during job execution.
+  #
+  # If an error occurs in the job execution, the
+  # Processor calls the Manager to create a new one
+  # to replace itself and exits.
+  #
   class Processor
-    # To prevent a memory leak, ensure that stats expire. However, they should take up a minimal amount of storage
-    # so keep them around for a long time
-    STATS_TIMEOUT = 24 * 60 * 60 * 365 * 5
-
-    include Util
-    include Actor
-
-    def self.default_middleware
-      Middleware::Chain.new do |m|
-        m.add Middleware::Server::Logging
-        m.add Middleware::Server::RetryJobs
-        if defined?(::ActiveRecord::Base)
-          require 'sidekiq/middleware/server/active_record'
-          m.add Sidekiq::Middleware::Server::ActiveRecord
-        end
-      end
+    include Sidekiq::Component
+
+    attr_reader :thread
+    attr_reader :job
+    attr_reader :capsule
+
+    def initialize(capsule, &block)
+      @config = @capsule = capsule
+      @callback = block
+      @down = false
+      @done = false
+      @job = nil
+      @thread = nil
+      @reloader = Sidekiq.default_configuration[:reloader]
+      @job_logger = (capsule.config[:job_logger] || Sidekiq::JobLogger).new(logger)
+      @retrier = Sidekiq::JobRetry.new(capsule)
     end
 
-    attr_accessor :proxy_id
+    def terminate(wait = false)
+      @done = true
+      return unless @thread
+      @thread.value if wait
+    end
 
-    def initialize(boss)
-      @boss = boss
+    def kill(wait = false)
+      @done = true
+      return unless @thread
+      # unlike the other actors, terminate does not wait
+      # for the thread to finish because we don't know how
+      # long the job will take to finish.  Instead we
+      # provide a `kill` method to call after the shutdown
+      # timeout passes.
+      @thread.raise ::Sidekiq::Shutdown
+      @thread.value if wait
     end
 
-    def process(work)
-      msgstr = work.message
-      queue = work.queue_name
+    def start
+      @thread ||= safe_thread("#{config.name}/processor", &method(:run))
+    end
 
-      @boss.async.real_thread(proxy_id, Thread.current)
+    private unless $TESTING
 
-      ack = false
-      begin
-        msg = Sidekiq.load_json(msgstr)
-        klass  = msg['class'.freeze].constantize
-        worker = klass.new
-        worker.jid = msg['jid'.freeze]
-
-        stats(worker, msg, queue) do
-          Sidekiq.server_middleware.invoke(worker, msg, queue) 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
-            ack = true
-            execute_job(worker, cloned(msg['args'.freeze]))
-          end
-        end
-        ack = true
-      rescue Sidekiq::Shutdown
-        # Had to force kill this job because it didn't finish
-        # within the timeout.  Don't acknowledge the work since
-        # we didn't properly finish it.
-        ack = false
-      rescue Exception => ex
-        handle_exception(ex, msg || { :message => msgstr })
-        raise
-      ensure
-        work.acknowledge if ack
-      end
+    def run
+      # By setting this thread-local, Sidekiq.redis will access +Sidekiq::Capsule#redis_pool+
+      # instead of the global pool in +Sidekiq::Config#redis_pool+.
+      Thread.current[:sidekiq_capsule] = @capsule
 
-      @boss.async.processor_done(current_actor)
+      process_one until @done
+      @callback.call(self)
+    rescue Sidekiq::Shutdown
+      @callback.call(self)
+    rescue Exception => ex
+      @callback.call(self, ex)
     end
 
-    def inspect
-      "<Processor##{object_id.to_s(16)}>"
+    def process_one(&block)
+      @job = fetch
+      process(@job) if @job
+      @job = nil
     end
 
-    def execute_job(worker, cloned_args)
-      worker.perform(*cloned_args)
+    def get_one
+      uow = capsule.fetcher.retrieve_work
+      if @down
+        logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }
+        @down = nil
+      end
+      uow
+    rescue Sidekiq::Shutdown
+    rescue => ex
+      handle_fetch_exception(ex)
     end
 
-    private
+    def fetch
+      j = get_one
+      if j && @done
+        j.requeue
+        nil
+      else
+        j
+      end
+    end
 
-    def thread_identity
-      @str ||= Thread.current.object_id.to_s(36)
+    def handle_fetch_exception(ex)
+      unless @down
+        @down = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        logger.error("Error fetching job: #{ex}")
+        handle_exception(ex)
+      end
+      sleep(1)
+      nil
     end
 
-    def stats(worker, msg, queue)
-      # Do not conflate errors from the job with errors caused by updating
-      # stats so calling code can react appropriately
-      retry_and_suppress_exceptions do
-        hash = Sidekiq.dump_json({:queue => queue, :payload => msg, :run_at => Time.now.to_i })
-        Sidekiq.redis do |conn|
-          conn.multi do
-            conn.hmset("#{identity}:workers", thread_identity, hash)
-            conn.expire("#{identity}:workers", 60*60*4)
+    def dispatch(job_hash, queue, jobstr)
+      # since middleware can mutate the job hash
+      # we need to clone it to report the original
+      # job structure to the Web UI
+      # or to push back to redis when retrying.
+      # To avoid costly and, most of the time, useless cloning here,
+      # we pass original String of JSON to respected methods
+      # to re-parse it there if we need access to the original, untouched job
+
+      @job_logger.prepare(job_hash) do
+        @retrier.global(jobstr, queue) do
+          @job_logger.call(job_hash, queue) do
+            stats(jobstr, 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 = Object.const_get(job_hash["class"])
+                inst = klass.new
+                inst.jid = job_hash["jid"]
+                @retrier.local(inst, jobstr, queue) do
+                  yield inst
+                end
+              end
+            end
           end
         end
       end
+    end
+
+    IGNORE_SHUTDOWN_INTERRUPTS = {Sidekiq::Shutdown => :never}
+    private_constant :IGNORE_SHUTDOWN_INTERRUPTS
+    ALLOW_SHUTDOWN_INTERRUPTS = {Sidekiq::Shutdown => :immediate}
+    private_constant :ALLOW_SHUTDOWN_INTERRUPTS
 
-      nowdate = Time.now.utc.strftime("%Y-%m-%d".freeze)
+    def process(uow)
+      jobstr = uow.job
+      queue = uow.queue_name
+
+      # Treat malformed JSON as a special case: job goes straight to the morgue.
+      job_hash = nil
       begin
-        yield
-      rescue Exception
-        retry_and_suppress_exceptions do
-          failed = "stat:failed:#{nowdate}"
-          Sidekiq.redis do |conn|
-            conn.multi do
-              conn.incrby("stat:failed".freeze, 1)
-              conn.incrby(failed, 1)
-              conn.expire(failed, STATS_TIMEOUT)
-            end
+        job_hash = Sidekiq.load_json(jobstr)
+      rescue => ex
+        handle_exception(ex, {context: "Invalid JSON for job", jobstr: jobstr})
+        now = Time.now.to_f
+        redis do |conn|
+          conn.multi do |xa|
+            xa.zadd("dead", now.to_s, jobstr)
+            xa.zremrangebyscore("dead", "-inf", now - @capsule.config[:dead_timeout_in_seconds])
+            xa.zremrangebyrank("dead", 0, - @capsule.config[:dead_max_jobs])
           end
         end
-        raise
-      ensure
-        retry_and_suppress_exceptions do
-          processed = "stat:processed:#{nowdate}"
-          Sidekiq.redis do |conn|
-            conn.multi do
-              conn.hdel("#{identity}:workers", thread_identity)
-              conn.incrby("stat:processed".freeze, 1)
-              conn.incrby(processed, 1)
-              conn.expire(processed, STATS_TIMEOUT)
+        return uow.acknowledge
+      end
+
+      ack = false
+      Thread.handle_interrupt(IGNORE_SHUTDOWN_INTERRUPTS) do
+        Thread.handle_interrupt(ALLOW_SHUTDOWN_INTERRUPTS) do
+          dispatch(job_hash, queue, jobstr) do |inst|
+            config.server_middleware.invoke(inst, job_hash, queue) do
+              execute_job(inst, job_hash["args"])
             end
           end
+          ack = true
+        rescue Sidekiq::Shutdown
+          # Had to force kill this job because it didn't finish
+          # within the timeout.  Don't acknowledge the work since
+          # we didn't properly finish it.
+        rescue Sidekiq::JobRetry::Handled => h
+          # this is the common case: job raised error and Sidekiq::JobRetry::Handled
+          # signals that we created a retry successfully.  We can acknowlege the job.
+          ack = true
+          e = h.cause || h
+          handle_exception(e, {context: "Job raised exception", job: job_hash})
+          raise e
+        rescue Exception => ex
+          # Unexpected error!  This is very bad and indicates an exception that got past
+          # the retry subsystem (e.g. network partition).  We won't acknowledge the job
+          # so it can be rescued when using Sidekiq Pro.
+          handle_exception(ex, {context: "Internal exception!", job: job_hash, jobstr: jobstr})
+          raise ex
+        end
+      ensure
+        if ack
+          uow.acknowledge
         end
       end
     end
 
-    # Deep clone the arguments passed to the worker so that if
-    # the message fails, what is pushed back onto Redis hasn't
-    # been mutated by the worker.
-    def cloned(ary)
-      Marshal.load(Marshal.dump(ary))
+    def execute_job(inst, cloned_args)
+      inst.perform(*cloned_args)
     end
 
-    # If an exception occurs in the block passed to this method, that block will be retried up to max_retries times.
-    # All exceptions will be swallowed and logged.
-    def retry_and_suppress_exceptions(max_retries = 5)
-      retry_count = 0
-      begin
-        yield
-      rescue => e
-        retry_count += 1
-        if retry_count <= max_retries
-          Sidekiq.logger.debug {"Suppressing and retrying error: #{e.inspect}"}
-          pause_for_recovery(retry_count)
-          retry
-        else
-          handle_exception(e, { :message => "Exhausted #{max_retries} retries"})
-        end
+    # 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 += amount }
+      end
+
+      def reset
+        @lock.synchronize {
+          val = @value
+          @value = 0
+          val
+        }
+      end
+    end
+
+    # jruby's Hash implementation is not threadsafe, so we wrap it in a mutex here
+    class SharedWorkState
+      def initialize
+        @work_state = {}
+        @lock = Mutex.new
+      end
+
+      def set(tid, hash)
+        @lock.synchronize { @work_state[tid] = hash }
+      end
+
+      def delete(tid)
+        @lock.synchronize { @work_state.delete(tid) }
+      end
+
+      def dup
+        @lock.synchronize { @work_state.dup }
+      end
+
+      def size
+        @lock.synchronize { @work_state.size }
+      end
+
+      def clear
+        @lock.synchronize { @work_state.clear }
       end
     end
 
-    def pause_for_recovery(retry_count)
-      sleep(retry_count)
+    PROCESSED = Counter.new
+    FAILURE = Counter.new
+    WORK_STATE = SharedWorkState.new
+
+    def stats(jobstr, queue)
+      WORK_STATE.set(tid, {queue: queue, payload: jobstr, run_at: Time.now.to_i})
+
+      begin
+        yield
+      rescue Exception
+        FAILURE.incr
+        raise
+      ensure
+        WORK_STATE.delete(tid)
+        PROCESSED.incr
+      end
     end
   end
 end

data/lib/sidekiq/rails.rb

@@ -1,38 +1,68 @@
+# frozen_string_literal: true
+
+require "sidekiq/job"
+require "rails"
+
 module Sidekiq
-  def self.hook_rails!
-    return if defined?(@delay_removed)
+  class Rails < ::Rails::Engine
+    class Reloader
+      def initialize(app = ::Rails.application)
+        @app = app
+      end
 
-    ActiveSupport.on_load(:active_record) do
-      include Sidekiq::Extensions::ActiveRecord
-    end
+      def call
+        params = (::Rails::VERSION::STRING >= "7.1") ? {source: "job.sidekiq"} : {}
+        @app.reloader.wrap(**params) do
+          yield
+        end
+      end
 
-    ActiveSupport.on_load(:action_mailer) do
-      extend Sidekiq::Extensions::ActionMailer
+      def inspect
+        "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
+      end
     end
 
-    Module.__send__(:include, Sidekiq::Extensions::Klass)
-  end
+    # By including the Options module, we allow AJs to directly control sidekiq features
+    # via the *sidekiq_options* class method and, for instance, not use AJ's retry system.
+    # AJ retries don't show up in the Sidekiq UI Retries tab, don't save any error data, can't be
+    # manually retried, don't automatically die, etc.
+    #
+    #   class SomeJob < ActiveJob::Base
+    #     queue_as :default
+    #     sidekiq_options retry: 3, backtrace: 10
+    #     def perform
+    #     end
+    #   end
+    initializer "sidekiq.active_job_integration" do
+      ActiveSupport.on_load(:active_job) do
+        include ::Sidekiq::Job::Options unless respond_to?(:sidekiq_options)
+      end
+    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)
+    initializer "sidekiq.backtrace_cleaner" do
+      Sidekiq.configure_server do |config|
+        config[:backtrace_cleaner] = ->(backtrace) { ::Rails.backtrace_cleaner.clean(backtrace) }
       end
     end
-  end
 
-  class Rails < ::Rails::Engine
-    initializer 'sidekiq' do
-      Sidekiq.hook_rails!
+    # This hook happens after all initializers are run, just before returning
+    # from config/environment.rb back to sidekiq/cli.rb.
+    #
+    # None of this matters on the client-side, only within the Sidekiq process itself.
+    config.after_initialize do
+      Sidekiq.configure_server do |config|
+        config[:reloader] = Sidekiq::Rails::Reloader.new
+
+        # This is the integration code necessary so that if a job uses `Rails.logger.info "Hello"`,
+        # it will appear in the Sidekiq console with all of the job context.
+        unless ::Rails.logger == config.logger || ::ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, $stdout)
+          if ::Rails::VERSION::STRING < "7.1"
+            ::Rails.logger.extend(::ActiveSupport::Logger.broadcast(config.logger))
+          else
+            ::Rails.logger.broadcast_to(config.logger)
+          end
+        end
+      end
     end
-  end if defined?(::Rails)
+  end
 end

data/lib/sidekiq/redis_client_adapter.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "set"
+require "redis_client"
+require "redis_client/decorator"
+
+module Sidekiq
+  class RedisClientAdapter
+    BaseError = RedisClient::Error
+    CommandError = RedisClient::CommandError
+
+    # You can add/remove items or clear the whole thing if you don't want deprecation warnings.
+    DEPRECATED_COMMANDS = %i[rpoplpush zrangebyscore zrevrange zrevrangebyscore getset hmset setex setnx].to_set
+
+    module CompatMethods
+      def info
+        @client.call("INFO") { |i| i.lines(chomp: true).map { |l| l.split(":", 2) }.select { |l| l.size == 2 }.to_h }
+      end
+
+      def evalsha(sha, keys, argv)
+        @client.call("EVALSHA", sha, keys.size, *keys, *argv)
+      end
+
+      # this is the set of Redis commands used by Sidekiq. Not guaranteed
+      # to be comprehensive, we use this as a performance enhancement to
+      # avoid calling method_missing on most commands
+      USED_COMMANDS = %w[bitfield bitfield_ro del exists expire flushdb
+        get hdel hget hgetall hincrby hlen hmget hset hsetnx incr incrby
+        lindex llen lmove lpop lpush lrange lrem mget mset ping pttl
+        publish rpop rpush sadd scard script set sismember smembers
+        srem ttl type unlink zadd zcard zincrby zrange zrem
+        zremrangebyrank zremrangebyscore]
+
+      USED_COMMANDS.each do |name|
+        define_method(name) do |*args|
+          @client.call(name, *args)
+        end
+      end
+
+      private
+
+      # this allows us to use methods like `conn.hmset(...)` instead of having to use
+      # redis-client's native `conn.call("hmset", ...)`
+      def method_missing(*args, &block)
+        warn("[sidekiq#5788] Redis has deprecated the `#{args.first}`command, called at #{caller(1..1)}") if DEPRECATED_COMMANDS.include?(args.first)
+        @client.call(*args, *block)
+      end
+      ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
+
+      def respond_to_missing?(name, include_private = false)
+        super # Appease the linter. We can't tell what is a valid command.
+      end
+    end
+
+    CompatClient = RedisClient::Decorator.create(CompatMethods)
+
+    class CompatClient
+      def config
+        @client.config
+      end
+    end
+
+    def initialize(options)
+      opts = client_opts(options)
+      @config = if opts.key?(:sentinels)
+        RedisClient.sentinel(**opts)
+      else
+        RedisClient.config(**opts)
+      end
+    end
+
+    def new_client
+      CompatClient.new(@config.new_client)
+    end
+
+    private
+
+    def client_opts(options)
+      opts = options.dup
+
+      if opts[:namespace]
+        raise ArgumentError, "Your Redis configuration uses the namespace '#{opts[:namespace]}' but this feature is no longer supported in Sidekiq 7+. See https://github.com/sidekiq/sidekiq/blob/main/docs/7.0-Upgrade.md#redis-namespace."
+      end
+
+      opts.delete(:size)
+      opts.delete(:pool_timeout)
+
+      if opts[:network_timeout]
+        opts[:timeout] = opts[:network_timeout]
+        opts.delete(:network_timeout)
+      end
+
+      if opts[:driver]
+        opts[:driver] = opts[:driver].to_sym
+      end
+
+      opts[:name] = opts.delete(:master_name) if opts.key?(:master_name)
+      opts[:role] = opts[:role].to_sym if opts.key?(:role)
+      opts.delete(:url) if opts.key?(:sentinels)
+
+      # Issue #3303, redis-rb will silently retry an operation.
+      # This can lead to duplicate jobs if Sidekiq::Client's LPUSH
+      # is performed twice but I believe this is much, much rarer
+      # than the reconnect silently fixing a problem; we keep it
+      # on by default.
+      opts[:reconnect_attempts] ||= 1
+
+      opts
+    end
+  end
+end