sidekiq 4.2.10 → 7.3.10

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

@@ -1,205 +0,0 @@
-require 'sidekiq/scheduled'
-require 'sidekiq/api'
-
-module Sidekiq
-  module Middleware
-    module Server
-      ##
-      # 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 retry attempts is 25 which works out to about 3 weeks
-      # of retries. You can pass a value for the max number of retry attempts when
-      # adding the middleware using the options hash:
-      #
-      #   Sidekiq.configure_server do |config|
-      #     config.server_middleware do |chain|
-      #       chain.add Sidekiq::Middleware::Server::RetryJobs, :max_retries => 7
-      #     end
-      #   end
-      #
-      # or limit the number of retries for a particular worker with:
-      #
-      #    class MyWorker
-      #      include Sidekiq::Worker
-      #      sidekiq_options :retry => 10
-      #    end
-      #
-      class RetryJobs
-        include Sidekiq::Util
-
-        DEFAULT_MAX_RETRY_ATTEMPTS = 25
-
-        def initialize(options = {})
-          @max_retries = options.fetch(:max_retries, DEFAULT_MAX_RETRY_ATTEMPTS)
-        end
-
-        def call(worker, msg, queue)
-          yield
-        rescue Sidekiq::Shutdown
-          # ignore, will be pushed back onto queue during hard_shutdown
-          raise
-        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(worker, msg, queue, e)
-        end
-
-        private
-
-        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
-
-          raise exception
-        end
-
-        def retries_exhausted(worker, msg, exception)
-          logger.debug { "Retries exhausted for job" }
-          begin
-            block = 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 #{worker.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.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 = [])
-          # In Ruby 2.1.0 only, check if exception is a result of shutdown.
-          return false unless defined?(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
-  end
-end

data/lib/sidekiq/util.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-require 'socket'
-require 'securerandom'
-require 'sidekiq/exception_handler'
-require 'sidekiq/core_ext'
-
-module Sidekiq
-  ##
-  # This module is part of Sidekiq core and not intended for extensions.
-  #
-  module Util
-    include ExceptionHandler
-
-    EXPIRY = 60 * 60 * 24
-
-    def watchdog(last_words)
-      yield
-    rescue Exception => ex
-      handle_exception(ex, { context: last_words })
-      raise ex
-    end
-
-    def safe_thread(name, &block)
-      Thread.new do
-        Thread.current['sidekiq_label'] = name
-        watchdog(name, &block)
-      end
-    end
-
-    def logger
-      Sidekiq.logger
-    end
-
-    def redis(&block)
-      Sidekiq.redis(&block)
-    end
-
-    def hostname
-      ENV['DYNO'] || Socket.gethostname
-    end
-
-    def process_nonce
-      @@process_nonce ||= SecureRandom.hex(6)
-    end
-
-    def identity
-      @@identity ||= "#{hostname}:#{$$}:#{process_nonce}"
-    end
-
-    def fire_event(event, reverse=false)
-      arr = Sidekiq.options[:lifecycle_events][event]
-      arr.reverse! if reverse
-      arr.each do |block|
-        begin
-          block.call
-        rescue => ex
-          handle_exception(ex, { context: "Exception during Sidekiq lifecycle event.", event: event })
-        end
-      end
-      arr.clear
-    end
-  end
-end

data/lib/sidekiq/worker.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-require 'sidekiq/client'
-require 'sidekiq/core_ext'
-
-module Sidekiq
-
-  ##
-  # Include this module in your worker class and you can easily create
-  # asynchronous jobs:
-  #
-  # class HardWorker
-  #   include Sidekiq::Worker
-  #
-  #   def perform(*args)
-  #     # do some work
-  #   end
-  # end
-  #
-  # Then in your Rails app, you can do this:
-  #
-  #   HardWorker.perform_async(1, 2, 3)
-  #
-  # Note that perform_async is a class method, perform is an instance method.
-  module Worker
-    attr_accessor :jid
-
-    def self.included(base)
-      raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}" if base.ancestors.any? {|c| c.name == 'ActiveJob::Base' }
-
-      base.extend(ClassMethods)
-      base.class_attribute :sidekiq_options_hash
-      base.class_attribute :sidekiq_retry_in_block
-      base.class_attribute :sidekiq_retries_exhausted_block
-    end
-
-    def logger
-      Sidekiq.logger
-    end
-
-    module ClassMethods
-
-      def delay(*args)
-        raise ArgumentError, "Do not call .delay on a Sidekiq::Worker class, call .perform_async"
-      end
-
-      def delay_for(*args)
-        raise ArgumentError, "Do not call .delay_for on a Sidekiq::Worker class, call .perform_in"
-      end
-
-      def delay_until(*args)
-        raise ArgumentError, "Do not call .delay_until on a Sidekiq::Worker class, call .perform_at"
-      end
-
-      def set(options)
-        Thread.current[:sidekiq_worker_set] = options
-        self
-      end
-
-      def perform_async(*args)
-        client_push('class' => self, 'args' => 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)
-
-        item = { 'class' => self, 'args' => args, 'at' => ts }
-
-        # Optimization to enqueue something now that is scheduled to go out now or in the past
-        item.delete('at'.freeze) if ts <= now
-
-        client_push(item)
-      end
-      alias_method :perform_at, :perform_in
-
-      ##
-      # Allows customization for this type of Worker.
-      # Legal options:
-      #
-      #   queue - use a named queue for this Worker, default 'default'
-      #   retry - enable the RetryJobs middleware for this Worker, *true* to use the default
-      #      or *Integer* count
-      #   backtrace - whether to save any error backtrace in the retry payload to display in web UI,
-      #      can be true, false or an integer number of lines to save, default *false*
-      #   pool - use the given Redis connection pool to push this type of job to a given shard.
-      #
-      # In practice, any option is allowed.  This is the main mechanism to configure the
-      # options for a specific job.
-      def sidekiq_options(opts={})
-        self.sidekiq_options_hash = get_sidekiq_options.merge(opts.stringify_keys)
-      end
-
-      def sidekiq_retry_in(&block)
-        self.sidekiq_retry_in_block = block
-      end
-
-      def sidekiq_retries_exhausted(&block)
-        self.sidekiq_retries_exhausted_block = block
-      end
-
-      def get_sidekiq_options # :nodoc:
-        self.sidekiq_options_hash ||= Sidekiq.default_worker_options
-      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
-        Sidekiq::Client.new(pool).push(hash)
-      end
-
-    end
-  end
-end