sidekiq 7.3.0 → 8.0.5

data/lib/sidekiq/config.rb

@@ -1,6 +1,6 @@
-require "forwardable"
+# frozen_string_literal: true
 
-require "set"
+require "forwardable"
 require "sidekiq/redis_connection"
 
 module Sidekiq
@@ -27,6 +27,7 @@ module Sidekiq
         startup: [],
         quiet: [],
         shutdown: [],
+        exit: [],
         # triggers when we fire the first heartbeat on startup OR repairing a network partition
         heartbeat: [],
         # triggers on EVERY heartbeat call, every 10 seconds
@@ -39,12 +40,22 @@ module Sidekiq
     }
 
     ERROR_HANDLER = ->(ex, ctx, cfg = Sidekiq.default_configuration) {
-      l = cfg.logger
-      l.warn(Sidekiq.dump_json(ctx)) unless ctx.empty?
-      l.warn("#{ex.class.name}: #{ex.message}")
-      unless ex.backtrace.nil?
-        backtrace = cfg[:backtrace_cleaner].call(ex.backtrace)
-        l.warn(backtrace.join("\n"))
+      Sidekiq::Context.with(ctx) do
+        dev = cfg[:environment] == "development"
+        fancy = dev && $stdout.tty? # 🎩
+        # Weird logic here but we want to show the backtrace in local
+        # development or if verbose logging is enabled.
+        #
+        # `full_message` contains the error class, message and backtrace
+        # `detailed_message` contains the error class and message
+        #
+        # Absolutely terrible API names. Not useful at all to have two
+        # methods with similar but obscure names.
+        if dev || cfg.logger.debug?
+          cfg.logger.info { ex.full_message(highlight: fancy) }
+        else
+          cfg.logger.info { ex.detailed_message(highlight: fancy) }
+        end
       end
     }
 
@@ -58,6 +69,13 @@ module Sidekiq
 
     def_delegators :@options, :[], :[]=, :fetch, :key?, :has_key?, :merge!, :dig
     attr_reader :capsules
+    attr_accessor :thread_priority
+
+    def inspect
+      "#<#{self.class.name} @options=#{
+        @options.except(:lifecycle_events, :reloader, :death_handlers, :error_handlers).inspect
+      }>"
+    end
 
     def to_json(*)
       Sidekiq.dump_json(@options)
@@ -183,7 +201,13 @@ module Sidekiq
 
     # register global singletons which can be accessed elsewhere
     def register(name, instance)
-      @directory[name] = instance
+      # logger.debug("register[#{name}] = #{instance}")
+      # Sidekiq Enterprise lazy registers a few services so we
+      # can't lock down this hash completely.
+      hash = @directory.dup
+      hash[name] = instance
+      @directory = hash.freeze
+      instance
     end
 
     # find a singleton
@@ -191,10 +215,16 @@ module Sidekiq
       # JNDI is just a fancy name for a hash lookup
       @directory.fetch(name) do |key|
         return nil unless default_class
-        @directory[key] = default_class.new(self)
+        register(key, default_class.new(self))
       end
     end
 
+    def freeze!
+      @directory.freeze
+      @options.freeze
+      true
+    end
+
     ##
     # Death handlers are called when all retries for a job have been exhausted and
     # the job dies.  It's the notification to your application
@@ -229,7 +259,7 @@ module Sidekiq
     end
 
     # Register a block to run at a point in the Sidekiq lifecycle.
-    # :startup, :quiet or :shutdown are valid events.
+    # :startup, :quiet, :shutdown, or :exit are valid events.
     #
     #   Sidekiq.configure_server do |config|
     #     config.on(:shutdown) do
@@ -273,13 +303,7 @@ module Sidekiq
         p ["!!!!!", ex]
       end
       @options[:error_handlers].each do |handler|
-        if parameter_size(handler) == 2
-          # TODO Remove in 8.0
-          logger.info { "DEPRECATION: Sidekiq exception handlers now take three arguments, see #{handler}" }
-          handler.call(ex, {_config: self}.merge(ctx))
-        else
-          handler.call(ex, ctx, self)
-        end
+        handler.call(ex, ctx, self)
       rescue Exception => e
         l = logger
         l.error "!!! ERROR HANDLER THREW AN ERROR !!!"

data/lib/sidekiq/deploy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sidekiq/redis_connection"
 require "time"
 

data/lib/sidekiq/embedded.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sidekiq/component"
 require "sidekiq/launcher"
 require "sidekiq/metrics/tracking"
@@ -32,6 +34,7 @@ module Sidekiq
     private
 
     def housekeeping
+      @config[:tag] ||= default_tag
       logger.info "Running in #{RUBY_DESCRIPTION}"
       logger.info Sidekiq::LICENSE
       logger.info "Upgrade to Sidekiq Pro for more features and support: https://sidekiq.org" unless defined?(::Sidekiq::Pro)
@@ -40,7 +43,7 @@ module Sidekiq
       # fire startup and start multithreading.
       info = config.redis_info
       ver = Gem::Version.new(info["redis_version"])
-      raise "You are connecting to Redis #{ver}, Sidekiq requires Redis 6.2.0 or greater" if ver < Gem::Version.new("6.2.0")
+      raise "You are connected to Redis #{ver}, Sidekiq requires Redis 7.0.0 or greater" if ver < Gem::Version.new("7.0.0")
 
       maxmemory_policy = info["maxmemory_policy"]
       if maxmemory_policy != "noeviction"

data/lib/sidekiq/iterable_job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sidekiq/job/iterable"
 
 # Iterable jobs are ones which provide a sequence to process using
@@ -44,6 +46,7 @@ module Sidekiq
     # def on_start
     # def on_resume
     # def on_stop
+    # def on_cancel
     # def on_complete
     # def around_iteration
     #

data/lib/sidekiq/job/interrupt_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sidekiq
   module Job
     class InterruptHandler

data/lib/sidekiq/job/iterable/active_record_enumerator.rb

@@ -22,7 +22,7 @@ module Sidekiq
         def batches
           Enumerator.new(-> { @relation.count }) do |yielder|
             @relation.find_in_batches(**@options, start: @cursor) do |batch|
-              yielder.yield(batch, batch.last.id)
+              yielder.yield(batch, batch.first.id)
             end
           end
         end
@@ -35,8 +35,8 @@ module Sidekiq
             options[:of] ||= options.delete(:batch_size)
 
             @relation.in_batches(**options, start: @cursor) do |relation|
-              last_record = relation.last
-              yielder.yield(relation, last_record.id)
+              first_record = relation.first
+              yielder.yield(relation, first_record.id)
             end
           end
         end

data/lib/sidekiq/job/iterable.rb

@@ -30,6 +30,42 @@ module Sidekiq
         @_cursor = nil
         @_start_time = nil
         @_runtime = 0
+        @_args = nil
+        @_cancelled = nil
+      end
+
+      def arguments
+        @_args
+      end
+
+      # Three days is the longest period you generally need to wait for a retry to
+      # execute when using the default retry scheme. We don't want to "forget" the job
+      # is cancelled before it has a chance to execute and cancel itself.
+      CANCELLATION_PERIOD = (3 * 86_400).to_s
+
+      # Set a flag in Redis to mark this job as cancelled.
+      # Cancellation is asynchronous and is checked at the start of iteration
+      # and every 5 seconds thereafter as part of the recurring state flush.
+      def cancel!
+        return @_cancelled if cancelled?
+
+        key = "it-#{jid}"
+        _, result, _ = Sidekiq.redis do |c|
+          c.pipelined do |p|
+            p.hsetnx(key, "cancelled", Time.now.to_i)
+            p.hget(key, "cancelled")
+            p.expire(key, Sidekiq::Job::Iterable::STATE_TTL, "nx")
+          end
+        end
+        @_cancelled = result.to_i
+      end
+
+      def cancelled?
+        @_cancelled
+      end
+
+      def cursor
+        @_cursor.freeze
       end
 
       # A hook to override that will be called when the job starts iterating.
@@ -59,6 +95,11 @@ module Sidekiq
       def on_stop
       end
 
+      # A hook to override that will be called when the job is cancelled.
+      #
+      def on_cancel
+      end
+
       # A hook to override that will be called when the job finished iterating.
       #
       def on_complete
@@ -91,13 +132,14 @@ module Sidekiq
       end
 
       # @api private
-      def perform(*arguments)
+      def perform(*args)
+        @_args = args.dup.freeze
         fetch_previous_iteration_state
 
         @_executions += 1
         @_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
 
-        enumerator = build_enumerator(*arguments, cursor: @_cursor)
+        enumerator = build_enumerator(*args, cursor: @_cursor)
         unless enumerator
           logger.info("'#build_enumerator' returned nil, skipping the job.")
           return
@@ -112,7 +154,7 @@ module Sidekiq
         end
 
         completed = catch(:abort) do
-          iterate_with_enumerator(enumerator, arguments)
+          iterate_with_enumerator(enumerator, args)
         end
 
         on_stop
@@ -128,6 +170,10 @@ module Sidekiq
 
       private
 
+      def is_cancelled?
+        @_cancelled = Sidekiq.redis { |c| c.hget("it-#{jid}", "cancelled") }
+      end
+
       def fetch_previous_iteration_state
         state = Sidekiq.redis { |conn| conn.hgetall(iteration_key) }
 
@@ -144,6 +190,13 @@ module Sidekiq
       STATE_TTL = 30 * 24 * 60 * 60 # one month
 
       def iterate_with_enumerator(enumerator, arguments)
+        if is_cancelled?
+          on_cancel
+          logger.info { "Job cancelled" }
+          return true
+        end
+
+        time_limit = Sidekiq.default_configuration[:timeout]
         found_record = false
         state_flushed_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
 
@@ -153,14 +206,25 @@ module Sidekiq
 
           is_interrupted = interrupted?
           if ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - state_flushed_at >= STATE_FLUSH_INTERVAL || is_interrupted
-            flush_state
+            _, _, cancelled = flush_state
             state_flushed_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            if cancelled
+              @_cancelled = true
+              on_cancel
+              logger.info { "Job cancelled" }
+              return true
+            end
           end
 
           return false if is_interrupted
 
-          around_iteration do
-            each_iteration(object, *arguments)
+          verify_iteration_time(time_limit, object) do
+            around_iteration do
+              each_iteration(object, *arguments)
+            rescue Exception
+              flush_state
+              raise
+            end
           end
         end
 
@@ -170,6 +234,16 @@ module Sidekiq
         @_runtime += (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @_start_time)
       end
 
+      def verify_iteration_time(time_limit, object)
+        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        yield
+        finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        total = finish - start
+        if total > time_limit
+          logger.warn { "Iteration took longer (%.2f) than Sidekiq's shutdown timeout (%d) when processing `%s`. This can lead to job processing problems during deploys" % [total, time_limit, object] }
+        end
+      end
+
       def reenqueue_iteration_job
         flush_state
         logger.debug { "Interrupting job (cursor=#{@_cursor.inspect})" }
@@ -203,7 +277,8 @@ module Sidekiq
         Sidekiq.redis do |conn|
           conn.multi do |pipe|
             pipe.hset(key, state)
-            pipe.expire(key, STATE_TTL)
+            pipe.expire(key, STATE_TTL, "nx")
+            pipe.hget(key, "cancelled")
           end
         end
       end

data/lib/sidekiq/job_logger.rb

@@ -2,52 +2,40 @@
 
 module Sidekiq
   class JobLogger
-    include Sidekiq::Component
-
     def initialize(config)
       @config = config
-      @logger = logger
-    end
-
-    # If true we won't do any job logging out of the box.
-    # The user is responsible for any logging.
-    def skip_default_logging?
-      config[:skip_default_job_logging]
+      @logger = @config.logger
+      @skip = !!@config[:skip_default_job_logging]
     end
 
     def call(item, queue)
-      return yield if skip_default_logging?
+      start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      @logger.info { "start" } unless @skip
 
-      begin
-        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-        @logger.info("start")
+      yield
 
-        yield
-
-        Sidekiq::Context.add(:elapsed, elapsed(start))
-        @logger.info("done")
-      rescue Exception
-        Sidekiq::Context.add(:elapsed, elapsed(start))
-        @logger.info("fail")
-
-        raise
-      end
+      Sidekiq::Context.add(:elapsed, elapsed(start))
+      @logger.info { "done" } unless @skip
+    rescue Exception
+      Sidekiq::Context.add(:elapsed, elapsed(start))
+      @logger.info { "fail" } unless @skip
+      raise
     end
 
     def prepare(job_hash, &block)
       # If we're using a wrapper class, like ActiveJob, use the "wrapped"
       # attribute to expose the underlying thing.
       h = {
-        class: job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"],
-        jid: job_hash["jid"]
+        jid: job_hash["jid"],
+        class: job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
       }
       h[:bid] = job_hash["bid"] if job_hash.has_key?("bid")
       h[:tags] = job_hash["tags"] if job_hash.has_key?("tags")
 
       Thread.current[:sidekiq_context] = h
       level = job_hash["log_level"]
-      if level && @logger.respond_to?(:log_at)
-        @logger.log_at(level, &block)
+      if level
+        @logger.with_level(level, &block)
       else
         yield
       end

data/lib/sidekiq/job_retry.rb

@@ -139,6 +139,10 @@ module Sidekiq
 
     private
 
+    def now_ms
+      ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond)
+    end
+
     # Note that +jobinst+ can be nil here if an error is raised before we can
     # instantiate the job instance.  All access must be guarded and
     # best effort.
@@ -149,17 +153,17 @@ module Sidekiq
 
       m = exception_message(exception)
       if m.respond_to?(:scrub!)
-        m.force_encoding("utf-8")
+        m.force_encoding(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["retried_at"] = now_ms
         msg["retry_count"] += 1
       else
-        msg["failed_at"] = Time.now.to_f
+        msg["failed_at"] = now_ms
         msg["retry_count"] = 0
       end
 
@@ -177,7 +181,7 @@ module Sidekiq
       return retries_exhausted(jobinst, msg, exception) if count >= max_retry_attempts
 
       rf = msg["retry_for"]
-      return retries_exhausted(jobinst, msg, exception) if rf && ((msg["failed_at"] + rf) < Time.now.to_f)
+      return retries_exhausted(jobinst, msg, exception) if rf && (time_for(msg["failed_at"]) + rf) < Time.now
 
       strategy, delay = delay_for(jobinst, count, exception, msg)
       case strategy
@@ -189,7 +193,7 @@ module Sidekiq
 
       # Logging here can break retries if the logging device raises ENOSPC #3979
       # logger.debug { "Failure! Retry #{count} in #{delay} seconds" }
-      jitter = rand(10) * (count + 1)
+      jitter = rand(10 * (count + 1))
       retry_at = Time.now.to_f + delay + jitter
       payload = Sidekiq.dump_json(msg)
       redis do |conn|
@@ -197,6 +201,14 @@ module Sidekiq
       end
     end
 
+    def time_for(item)
+      if item.is_a?(Float)
+        Time.at(item)
+      else
+        Time.at(item / 1000, item % 1000)
+      end
+    end
+
     # returns (strategy, seconds)
     def delay_for(jobinst, count, exception, msg)
       rv = begin

data/lib/sidekiq/job_util.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "securerandom"
 require "time"
 
@@ -56,10 +58,14 @@ module Sidekiq
       item["class"] = item["class"].to_s
       item["queue"] = item["queue"].to_s
       item["retry_for"] = item["retry_for"].to_i if item["retry_for"]
-      item["created_at"] ||= Time.now.to_f
+      item["created_at"] ||= now_in_millis
       item
     end
 
+    def now_in_millis
+      ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond)
+    end
+
     def normalized_hash(item_class)
       if item_class.is_a?(Class)
         raise(ArgumentError, "Message must include a Sidekiq::Job class, not class name: #{item_class.ancestors.inspect}") unless item_class.respond_to?(:get_sidekiq_options)

data/lib/sidekiq/launcher.rb

@@ -36,8 +36,8 @@ module Sidekiq
     # has a heartbeat thread, caller can use `async_beat: false`
     # and instead have thread call Launcher#heartbeat every N seconds.
     def run(async_beat: true)
-      Sidekiq.freeze!
       logger.debug { @config.merge!({}) }
+      Sidekiq.freeze!
       @thread = safe_thread("heartbeat", &method(:start_heartbeat)) if async_beat
       @poller.start
       @managers.each(&:start)
@@ -68,6 +68,7 @@ module Sidekiq
       stoppers.each(&:join)
 
       clear_heartbeat
+      fire_event(:exit, reverse: true)
     end
 
     def stopping?
@@ -81,7 +82,7 @@ module Sidekiq
       ❤
     end
 
-    private unless $TESTING
+    private
 
     BEAT_PAUSE = 10
 

data/lib/sidekiq/logger.rb

@@ -22,92 +22,41 @@ module Sidekiq
     end
   end
 
-  module LoggingUtils
-    LEVELS = {
-      "debug" => 0,
-      "info" => 1,
-      "warn" => 2,
-      "error" => 3,
-      "fatal" => 4
-    }
-    LEVELS.default_proc = proc do |_, level|
-      puts("Invalid log level: #{level.inspect}")
-      nil
-    end
-
-    LEVELS.each do |level, numeric_level|
-      define_method(:"#{level}?") do
-        local_level.nil? ? super() : local_level <= numeric_level
-      end
-    end
-
-    def local_level
-      Thread.current[:sidekiq_log_level]
-    end
-
-    def local_level=(level)
-      case level
-      when Integer
-        Thread.current[:sidekiq_log_level] = level
-      when Symbol, String
-        Thread.current[:sidekiq_log_level] = LEVELS[level.to_s]
-      when nil
-        Thread.current[:sidekiq_log_level] = nil
-      else
-        raise ArgumentError, "Invalid log level: #{level.inspect}"
-      end
-    end
-
-    def level
-      local_level || super
-    end
-
-    # Change the thread-local level for the duration of the given block.
-    def log_at(level)
-      old_local_level = local_level
-      self.local_level = level
-      yield
-    ensure
-      self.local_level = old_local_level
-    end
-  end
-
   class Logger < ::Logger
-    include LoggingUtils
-
     module Formatters
+      COLORS = {
+        "DEBUG" => "\e[1;32mDEBUG\e[0m", # green
+        "INFO" => "\e[1;34mINFO \e[0m", # blue
+        "WARN" => "\e[1;33mWARN \e[0m", # yellow
+        "ERROR" => "\e[1;31mERROR\e[0m", # red
+        "FATAL" => "\e[1;35mFATAL\e[0m" # pink
+      }
       class Base < ::Logger::Formatter
         def tid
           Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
         end
 
-        def ctx
-          Sidekiq::Context.current
-        end
-
-        def format_context
-          if ctx.any?
-            " " + ctx.compact.map { |k, v|
-              case v
-              when Array
-                "#{k}=#{v.join(",")}"
-              else
-                "#{k}=#{v}"
-              end
-            }.join(" ")
-          end
+        def format_context(ctxt = Sidekiq::Context.current)
+          (ctxt.size == 0) ? "" : " #{ctxt.map { |k, v|
+            case v
+            when Array
+              "#{k}=#{v.join(",")}"
+            else
+              "#{k}=#{v}"
+            end
+          }.join(" ")}"
         end
       end
 
       class Pretty < Base
         def call(severity, time, program_name, message)
-          "#{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context} #{severity}: #{message}\n"
+          "#{Formatters::COLORS[severity]} #{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
         end
       end
 
       class WithoutTimestamp < Pretty
         def call(severity, time, program_name, message)
-          "pid=#{::Process.pid} tid=#{tid}#{format_context} #{severity}: #{message}\n"
+          "#{Formatters::COLORS[severity]} pid=#{::Process.pid} tid=#{tid} #{format_context}: #{message}\n"
         end
       end
 
@@ -120,7 +69,7 @@ module Sidekiq
             lvl: severity,
             msg: message
           }
-          c = ctx
+          c = Sidekiq::Context.current
           hash["ctx"] = c unless c.empty?
 
           Sidekiq.dump_json(hash) << "\n"

data/lib/sidekiq/manager.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "sidekiq/processor"
-require "set"
 
 module Sidekiq
   ##