sidekiq 6.0.0

data/lib/sidekiq/delay.rb

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

data/lib/sidekiq/exception_handler.rb

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

data/lib/sidekiq/extensions/action_mailer.rb

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

data/lib/sidekiq/extensions/active_record.rb

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

data/lib/sidekiq/extensions/class_methods.rb

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

data/lib/sidekiq/extensions/generic_proxy.rb

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

data/lib/sidekiq/fetch.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module Sidekiq
+  class BasicFetch
+    # We want the fetch operation to timeout every few seconds so the thread
+    # can check if the process is shutting down.
+    TIMEOUT = 2
+
+    UnitOfWork = Struct.new(:queue, :job) {
+      def acknowledge
+        # nothing to do
+      end
+
+      def queue_name
+        queue.sub(/.*queue:/, "")
+      end
+
+      def requeue
+        Sidekiq.redis do |conn|
+          conn.rpush("queue:#{queue_name}", job)
+        end
+      end
+    }
+
+    def initialize(options)
+      @strictly_ordered_queues = !!options[:strict]
+      @queues = options[:queues].map { |q| "queue:#{q}" }
+      if @strictly_ordered_queues
+        @queues = @queues.uniq
+        @queues << TIMEOUT
+      end
+    end
+
+    def retrieve_work
+      work = Sidekiq.redis { |conn| conn.brpop(*queues_cmd) }
+      UnitOfWork.new(*work) if work
+    end
+
+    # Creating the Redis#brpop command takes into account any
+    # configured queue weights. By default Redis#brpop returns
+    # data from the first queue that has pending elements. We
+    # recreate the queue command each time we invoke Redis#brpop
+    # to honor weights and avoid queue starvation.
+    def queues_cmd
+      if @strictly_ordered_queues
+        @queues
+      else
+        queues = @queues.shuffle.uniq
+        queues << TIMEOUT
+        queues
+      end
+    end
+
+    # By leaving this as a class method, it can be pluggable and used by the Manager actor. Making it
+    # an instance method will make it async to the Fetcher actor
+    def self.bulk_requeue(inprogress, options)
+      return if inprogress.empty?
+
+      Sidekiq.logger.debug { "Re-queueing terminated jobs" }
+      jobs_to_requeue = {}
+      inprogress.each do |unit_of_work|
+        jobs_to_requeue[unit_of_work.queue_name] ||= []
+        jobs_to_requeue[unit_of_work.queue_name] << unit_of_work.job
+      end
+
+      Sidekiq.redis do |conn|
+        conn.pipelined do
+          jobs_to_requeue.each do |queue, jobs|
+            conn.rpush("queue:#{queue}", jobs)
+          end
+        end
+      end
+      Sidekiq.logger.info("Pushed #{inprogress.size} jobs back to Redis")
+    rescue => ex
+      Sidekiq.logger.warn("Failed to requeue #{inprogress.size} jobs: #{ex.message}")
+    end
+  end
+end

data/lib/sidekiq/job_logger.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  class JobLogger
+    def initialize(logger = Sidekiq.logger)
+      @logger = logger
+    end
+
+    def call(item, queue)
+      start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      @logger.info("start")
+
+      yield
+
+      with_elapsed_time_context(start) do
+        @logger.info("done")
+      end
+    rescue Exception
+      with_elapsed_time_context(start) do
+        @logger.info("fail")
+      end
+
+      raise
+    end
+
+    def with_job_hash_context(job_hash, &block)
+      @logger.with_context(job_hash_context(job_hash), &block)
+    end
+
+    def job_hash_context(job_hash)
+      # If we're using a wrapper class, like ActiveJob, use the "wrapped"
+      # attribute to expose the underlying thing.
+      h = {
+        class: job_hash["wrapped"] || job_hash["class"],
+        jid: job_hash["jid"],
+      }
+      h[:bid] = job_hash["bid"] if job_hash["bid"]
+      h
+    end
+
+    def with_elapsed_time_context(start, &block)
+      @logger.with_context(elapsed_time_context(start), &block)
+    end
+
+    def elapsed_time_context(start)
+      {elapsed: elapsed(start).to_s}
+    end
+
+    private
+
+    def elapsed(start)
+      (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start).round(3)
+    end
+  end
+end

data/lib/sidekiq/job_retry.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+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 Handled < ::RuntimeError; end
+    class Skip < Handled; 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 Handled => 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"]
+        attempt_retry(nil, msg, queue, e)
+      else
+        Sidekiq.death_handlers.each do |handler|
+          handler.call(msg, e)
+        rescue => handler_ex
+          handle_exception(handler_ex, {context: "Error calling death handler", job: msg})
+        end
+      end
+
+      raise Handled
+    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 Handled => 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"] = (msg["retry_queue"] || queue)
+
+      m = exception_message(exception)
+      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)
+        # Logging here can break retries if the logging device raises ENOSPC #3979
+        # 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)
+      begin
+        block = worker&.sidekiq_retries_exhausted_block
+        block&.call(msg, exception)
+      rescue => e
+        handle_exception(e, {context: "Error calling retries_exhausted", job: msg})
+      end
+
+      Sidekiq.death_handlers.each do |handler|
+        handler.call(msg, exception)
+      rescue => e
+        handle_exception(e, {context: "Error calling death handler", job: msg})
+      end
+
+      send_to_morgue(msg) unless msg["dead"] == false
+    end
+
+    def send_to_morgue(msg)
+      logger.info { "Adding dead #{msg["class"]} job #{msg["jid"]}" }
+      payload = Sidekiq.dump_json(msg)
+      DeadSet.new.kill(payload, notify_failure: false)
+    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)
+      if 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
+    def seconds_to_delay(count)
+      (count**4) + 15 + (rand(30) * (count + 1))
+    end
+
+    def retry_in(worker, count, exception)
+      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
+    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
+
+    # Extract message from exception.
+    # Set a default if the message raises an error
+    def exception_message(exception)
+      # App code can stuff all sorts of crazy binary data into the error message
+      # that won't convert to JSON.
+      exception.message.to_s[0, 10_000]
+    rescue
+      +"!!! ERROR MESSAGE THREW AN ERROR !!!"
+    end
+  end
+end