sidekiq 7.3.9 → 8.0.1

data/lib/sidekiq/client.rb

@@ -67,9 +67,7 @@ module Sidekiq
         c.pipelined do |p|
           p.hsetnx(key, "cancelled", Time.now.to_i)
           p.hget(key, "cancelled")
-          p.expire(key, Sidekiq::Job::Iterable::STATE_TTL)
-          # TODO When Redis 7.2 is required
-          # p.expire(key, Sidekiq::Job::Iterable::STATE_TTL, "nx")
+          p.expire(key, Sidekiq::Job::Iterable::STATE_TTL, "nx")
         end
       end
       result.to_i
@@ -266,22 +264,21 @@ module Sidekiq
       if payloads.first.key?("at")
         conn.zadd("schedule", payloads.flat_map { |hash|
           at = hash["at"].to_s
-          # ActiveJob sets this but the job has not been enqueued yet
-          hash.delete("enqueued_at")
-          # TODO: Use hash.except("at") when support for Ruby 2.7 is dropped
-          hash = hash.dup
-          hash.delete("at")
+          # ActiveJob sets enqueued_at but the job has not been enqueued yet
+          hash = hash.except("enqueued_at", "at")
           [at, Sidekiq.dump_json(hash)]
         })
       else
-        queue = payloads.first["queue"]
-        now = Time.now.to_f
-        to_push = payloads.map { |entry|
-          entry["enqueued_at"] = now
-          Sidekiq.dump_json(entry)
-        }
-        conn.sadd("queues", [queue])
-        conn.lpush("queue:#{queue}", to_push)
+        now = ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond) # milliseconds since the epoch
+        grouped_queues = payloads.group_by { |job| job["queue"] }
+        conn.sadd("queues", grouped_queues.keys)
+        grouped_queues.each do |queue, grouped_payloads|
+          to_push = grouped_payloads.map { |entry|
+            entry["enqueued_at"] = now
+            Sidekiq.dump_json(entry)
+          }
+          conn.lpush("queue:#{queue}", to_push)
+        end
       end
     end
   end

data/lib/sidekiq/component.rb

@@ -1,11 +1,38 @@
 # frozen_string_literal: true
 
 module Sidekiq
+  # Ruby's default thread priority is 0, which uses 100ms time slices.
+  # This can lead to some surprising thread starvation; if using a lot of
+  # CPU-heavy concurrency, it may take several seconds before a Thread gets
+  # on the CPU.
+  #
+  # Negative priorities lower the timeslice by half, so -1 = 50ms, -2 = 25ms, etc.
+  # With more frequent timeslices, we reduce the risk of unintentional timeouts
+  # and starvation.
+  #
+  # Customize like so:
+  #
+  #   Sidekiq.configure_server do |cfg|
+  #     cfg.thread_priority = 0
+  #   end
+  #
+  DEFAULT_THREAD_PRIORITY = -1
+
   ##
   # Sidekiq::Component assumes a config instance is available at @config
   module Component # :nodoc:
     attr_reader :config
 
+    # This is epoch milliseconds, appropriate for persistence
+    def real_ms
+      ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond)
+    end
+
+    # used for time difference and relative comparisons, not persistence.
+    def mono_ms
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
+    end
+
     def watchdog(last_words)
       yield
     rescue Exception => ex
@@ -13,11 +40,11 @@ module Sidekiq
       raise ex
     end
 
-    def safe_thread(name, &block)
+    def safe_thread(name, priority: nil, &block)
       Thread.new do
         Thread.current.name = "sidekiq.#{name}"
         watchdog(name, &block)
-      end
+      end.tap { |t| t.priority = (priority || config.thread_priority || DEFAULT_THREAD_PRIORITY) }
     end
 
     def logger
@@ -86,5 +113,16 @@ module Sidekiq
         end.join(", ")
       }>"
     end
+
+    def default_tag(dir = Dir.pwd)
+      name = File.basename(dir)
+      prevdir = File.dirname(dir) # Capistrano release directory?
+      if name.to_i != 0 && prevdir
+        if File.basename(prevdir) == "releases"
+          return File.basename(File.dirname(prevdir))
+        end
+      end
+      name
+    end
   end
 end

data/lib/sidekiq/config.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "forwardable"
-
-require "set"
 require "sidekiq/redis_connection"
 
 module Sidekiq
@@ -41,12 +39,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
     }
 
@@ -60,6 +68,7 @@ module Sidekiq
 
     def_delegators :@options, :[], :[]=, :fetch, :key?, :has_key?, :merge!, :dig
     attr_reader :capsules
+    attr_accessor :thread_priority
 
     def inspect
       "#<#{self.class.name} @options=#{
@@ -293,13 +302,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/embedded.rb

@@ -34,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)

data/lib/sidekiq/iterable_job.rb

@@ -46,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/iterable.rb

@@ -54,9 +54,7 @@ module Sidekiq
           c.pipelined do |p|
             p.hsetnx(key, "cancelled", Time.now.to_i)
             p.hget(key, "cancelled")
-            # TODO When Redis 7.2 is required
-            # p.expire(key, Sidekiq::Job::Iterable::STATE_TTL, "nx")
-            p.expire(key, Sidekiq::Job::Iterable::STATE_TTL)
+            p.expire(key, Sidekiq::Job::Iterable::STATE_TTL, "nx")
           end
         end
         @_cancelled = result.to_i
@@ -66,6 +64,10 @@ module Sidekiq
         @_cancelled
       end
 
+      def cursor
+        @_cursor.freeze
+      end
+
       # A hook to override that will be called when the job starts iterating.
       #
       # It is called only once, for the first time.
@@ -93,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
@@ -184,6 +191,7 @@ module Sidekiq
 
       def iterate_with_enumerator(enumerator, arguments)
         if is_cancelled?
+          on_cancel
           logger.info { "Job cancelled" }
           return true
         end
@@ -202,6 +210,7 @@ module Sidekiq
             state_flushed_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
             if cancelled
               @_cancelled = true
+              on_cancel
               logger.info { "Job cancelled" }
               return true
             end
@@ -265,7 +274,7 @@ 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

data/lib/sidekiq/job_logger.rb

@@ -26,16 +26,16 @@ module Sidekiq
       # 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

@@ -58,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

@@ -81,7 +81,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
   ##