sidekiq 5.2.6

data/lib/sidekiq/fetch.rb

@@ -0,0 +1,81 @@
+# 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) do
+      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
+    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,25 @@
+# frozen_string_literal: true
+module Sidekiq
+  class JobLogger
+
+    def call(item, queue)
+      start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      logger.info("start")
+      yield
+      logger.info("done: #{elapsed(start)} sec")
+    rescue Exception
+      logger.info("fail: #{elapsed(start)} sec")
+      raise
+    end
+
+    private
+
+    def elapsed(start)
+      (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start).round(3)
+    end
+
+    def logger
+      Sidekiq.logger
+    end
+  end
+end

data/lib/sidekiq/job_retry.rb

@@ -0,0 +1,262 @@
+# 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|
+          begin
+            handler.call(msg, e)
+          rescue => handler_ex
+            handle_exception(handler_ex, { context: "Error calling death handler", job: msg })
+          end
+        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'] = if msg['retry_queue']
+        msg['retry_queue']
+      else
+        queue
+      end
+
+      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 && worker.sidekiq_retries_exhausted_block
+        block.call(msg, exception) if block
+      rescue => e
+        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
+    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 && 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)
+      begin
+        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
+    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)
+      begin
+        # 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 !!!".dup
+      end
+    end
+
+  end
+end

data/lib/sidekiq/launcher.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+require 'sidekiq/manager'
+require 'sidekiq/fetch'
+require 'sidekiq/scheduled'
+
+module Sidekiq
+  # The Launcher is a very simple Actor whose job is to
+  # start, monitor and stop the core Actors in Sidekiq.
+  # If any of these actors die, the Sidekiq process exits
+  # immediately.
+  class Launcher
+    include Util
+
+    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
+      @done = false
+      @options = options
+    end
+
+    def run
+      @thread = safe_thread("heartbeat", &method(:start_heartbeat))
+      @poller.start
+      @manager.start
+    end
+
+    # Stops this instance from processing any more jobs,
+    #
+    def quiet
+      @done = true
+      @manager.quiet
+      @poller.terminate
+    end
+
+    # Shuts down the process.  This method does not
+    # return until all work is complete and cleaned up.
+    # It can take up to the timeout to complete.
+    def stop
+      deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + @options[:timeout]
+
+      @done = true
+      @manager.quiet
+      @poller.terminate
+
+      @manager.stop(deadline)
+
+      # Requeue everything in case there was a worker who grabbed work while stopped
+      # This call is a no-op in Sidekiq but necessary for Sidekiq Pro.
+      strategy = (@options[:fetch] || Sidekiq::BasicFetch)
+      strategy.bulk_requeue([], @options)
+
+      clear_heartbeat
+    end
+
+    def stopping?
+      @done
+    end
+
+    private unless $TESTING
+
+    def heartbeat
+      results = Sidekiq::CLI::PROCTITLES.map {|x| x.(self, to_data) }
+      results.compact!
+      $0 = results.join(' ')
+
+      ❤
+    end
+
+    def ❤
+      key = identity
+      fails = procd = 0
+      begin
+        fails = Processor::FAILURE.reset
+        procd = Processor::PROCESSED.reset
+        curstate = Processor::WORKER_STATE.dup
+
+        workers_key = "#{key}:workers"
+        nowdate = Time.now.utc.strftime("%Y-%m-%d")
+        Sidekiq.redis do |conn|
+          conn.multi do
+            conn.incrby("stat:processed", procd)
+            conn.incrby("stat:processed:#{nowdate}", procd)
+            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)
+            curstate.each_pair do |tid, hash|
+              conn.hset(workers_key, tid, Sidekiq.dump_json(hash))
+            end
+            conn.expire(workers_key, 60)
+          end
+        end
+        fails = procd = 0
+
+        _, exists, _, _, msg = Sidekiq.redis do |conn|
+          conn.multi do
+            conn.sadd('processes', key)
+            conn.exists(key)
+            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
+        end
+
+        # first heartbeat or recovering from an outage and need to reestablish our heartbeat
+        fire_event(:heartbeat) if !exists
+
+        return unless msg
+
+        ::Process.kill(msg, $$)
+      rescue => e
+        # ignore all redis/network issues
+        logger.error("heartbeat: #{e.message}")
+        # don't lose the counts if there was a network issue
+        Processor::PROCESSED.incr(procd)
+        Processor::FAILURE.incr(fails)
+      end
+    end
+
+    def start_heartbeat
+      while true
+        heartbeat
+        sleep 5
+      end
+      Sidekiq.logger.info("Heartbeat stopping...")
+    end
+
+    def to_data
+      @data ||= begin
+        {
+          'hostname' => hostname,
+          'started_at' => Time.now.to_f,
+          'pid' => $$,
+          'tag' => @options[:tag] || '',
+          'concurrency' => @options[:concurrency],
+          'queues' => @options[:queues].uniq,
+          'labels' => @options[:labels],
+          'identity' => identity,
+        }
+      end
+    end
+
+    def to_json
+      @json ||= begin
+        # this data changes infrequently so dump it to a string
+        # now so we don't need to dump it every heartbeat.
+        Sidekiq.dump_json(to_data)
+      end
+    end
+
+    def clear_heartbeat
+      # Remove record from Redis since we are shutting down.
+      # Note we don't stop the heartbeat thread; if the process
+      # doesn't actually exit, it'll reappear in the Web UI.
+      Sidekiq.redis do |conn|
+        conn.pipelined do
+          conn.srem('processes', identity)
+          conn.del("#{identity}:workers")
+        end
+      end
+    rescue
+      # best effort, ignore network errors
+    end
+
+  end
+end