sidekiq 7.3.9 → 8.0.0.beta2

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_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

@@ -81,13 +81,9 @@ module Sidekiq
           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|
+        def format_context(ctxt = Sidekiq::Context.current)
+          if ctxt.size > 0
+            ctxt.map { |k, v|
               case v
               when Array
                 "#{k}=#{v.join(",")}"
@@ -101,13 +97,13 @@ module Sidekiq
 
       class Pretty < Base
         def call(severity, time, program_name, message)
-          "#{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context} #{severity}: #{message}\n"
+          "#{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid} #{format_context} #{severity}: #{message}\n"
         end
       end
 
       class WithoutTimestamp < Pretty
         def call(severity, time, program_name, message)
-          "pid=#{::Process.pid} tid=#{tid}#{format_context} #{severity}: #{message}\n"
+          "pid=#{::Process.pid} tid=#{tid} #{format_context} #{severity}: #{message}\n"
         end
       end
 
@@ -120,7 +116,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
   ##

data/lib/sidekiq/metrics/query.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-require "sidekiq"
 require "date"
-require "set"
-
+require "sidekiq"
 require "sidekiq/metrics/shared"
 
 module Sidekiq
@@ -12,7 +10,7 @@ module Sidekiq
     # Caller sets a set of attributes to act as filters. {#fetch} will call
     # Redis and return a Hash of results.
     #
-    # NB: all metrics and times/dates are UTC only. We specifically do not
+    # NB: all metrics and times/dates are UTC only. We explicitly do not
     # support timezones.
     class Query
       def initialize(pool: nil, now: Time.now)
@@ -21,23 +19,46 @@ module Sidekiq
         @klass = nil
       end
 
+      ROLLUPS = {
+        # minutely aggregates per minute
+        minutely: [60, ->(time) { time.strftime("j|%y%m%d|%-H:%M") }],
+        # hourly aggregates every 10 minutes so we'll have six data points per hour
+        hourly: [600, ->(time) {
+          m = time.min
+          mins = (m < 10) ? "0" : m.to_s[0]
+          time.strftime("j|%y%m%d|%-H:#{mins}")
+        }]
+      }
+
       # Get metric data for all jobs from the last hour
       #  +class_filter+: return only results for classes matching filter
-      def top_jobs(class_filter: nil, minutes: 60)
-        result = Result.new
-
+      #  +minutes+: the number of fine-grained minute buckets to retrieve
+      #  +hours+: the number of coarser-grained 10-minute buckets to retrieve, in hours
+      def top_jobs(class_filter: nil, minutes: nil, hours: nil)
         time = @time
+        minutes = 60 unless minutes || hours
+
+        # DoS protection, sanity check
+        minutes = 60 if minutes && minutes > 480
+        hours = 72 if hours && hours > 72
+
+        granularity = hours ? :hourly : :minutely
+        result = Result.new(granularity)
+        result.ends_at = time
+        count = hours ? hours * 6 : minutes
+        stride, keyproc = ROLLUPS[granularity]
+
         redis_results = @pool.with do |conn|
           conn.pipelined do |pipe|
-            minutes.times do |idx|
-              key = "j|#{time.strftime("%Y%m%d")}|#{time.hour}:#{time.min}"
+            count.times do |idx|
+              key = keyproc.call(time)
               pipe.hgetall key
-              result.prepend_bucket time
-              time -= 60
+              time -= stride
             end
           end
         end
 
+        result.starts_at = time
         time = @time
         redis_results.each do |hash|
           hash.each do |k, v|
@@ -45,63 +66,66 @@ module Sidekiq
             next if class_filter && !class_filter.match?(kls)
             result.job_results[kls].add_metric metric, time, v.to_i
           end
-          time -= 60
+          time -= stride
         end
 
-        result.marks = fetch_marks(result.starts_at..result.ends_at)
-
+        result.marks = fetch_marks(result.starts_at..result.ends_at, granularity)
         result
       end
 
-      def for_job(klass, minutes: 60)
-        result = Result.new
-
+      def for_job(klass, minutes: nil, hours: nil)
         time = @time
+        minutes = 60 unless minutes || hours
+
+        # DoS protection, sanity check
+        minutes = 60 if minutes && minutes > 480
+        hours = 72 if hours && hours > 72
+
+        granularity = hours ? :hourly : :minutely
+        result = Result.new(granularity)
+        result.ends_at = time
+        count = hours ? hours * 6 : minutes
+        stride, keyproc = ROLLUPS[granularity]
+
         redis_results = @pool.with do |conn|
           conn.pipelined do |pipe|
-            minutes.times do |idx|
-              key = "j|#{time.strftime("%Y%m%d")}|#{time.hour}:#{time.min}"
+            count.times do |idx|
+              key = keyproc.call(time)
               pipe.hmget key, "#{klass}|ms", "#{klass}|p", "#{klass}|f"
-              result.prepend_bucket time
-              time -= 60
+              time -= stride
             end
           end
         end
 
+        result.starts_at = time
         time = @time
         @pool.with do |conn|
           redis_results.each do |(ms, p, f)|
             result.job_results[klass].add_metric "ms", time, ms.to_i if ms
             result.job_results[klass].add_metric "p", time, p.to_i if p
             result.job_results[klass].add_metric "f", time, f.to_i if f
-            result.job_results[klass].add_hist time, Histogram.new(klass).fetch(conn, time).reverse
-            time -= 60
+            result.job_results[klass].add_hist time, Histogram.new(klass).fetch(conn, time).reverse if minutes
+            time -= stride
           end
         end
 
-        result.marks = fetch_marks(result.starts_at..result.ends_at)
-
+        result.marks = fetch_marks(result.starts_at..result.ends_at, granularity)
         result
       end
 
-      class Result < Struct.new(:starts_at, :ends_at, :size, :buckets, :job_results, :marks)
-        def initialize
+      class Result < Struct.new(:granularity, :starts_at, :ends_at, :size, :job_results, :marks)
+        def initialize(granularity = :minutely)
           super
-          self.buckets = []
+          self.granularity = granularity
           self.marks = []
-          self.job_results = Hash.new { |h, k| h[k] = JobResult.new }
-        end
-
-        def prepend_bucket(time)
-          buckets.unshift time.strftime("%H:%M")
-          self.ends_at ||= time
-          self.starts_at = time
+          self.job_results = Hash.new { |h, k| h[k] = JobResult.new(granularity) }
         end
       end
 
-      class JobResult < Struct.new(:series, :hist, :totals)
-        def initialize
+      class JobResult < Struct.new(:granularity, :series, :hist, :totals)
+        def initialize(granularity = :minutely)
           super
+          self.granularity = granularity
           self.series = Hash.new { |h, k| h[k] = Hash.new(0) }
           self.hist = Hash.new { |h, k| h[k] = [] }
           self.totals = Hash.new(0)
@@ -109,14 +133,14 @@ module Sidekiq
 
         def add_metric(metric, time, value)
           totals[metric] += value
-          series[metric][time.strftime("%H:%M")] += value
+          series[metric][Query.bkt_time_s(time, granularity)] += value
 
           # Include timing measurements in seconds for convenience
           add_metric("s", time, value / 1000.0) if metric == "ms"
         end
 
         def add_hist(time, hist_result)
-          hist[time.strftime("%H:%M")] = hist_result
+          hist[Query.bkt_time_s(time, granularity)] = hist_result
         end
 
         def total_avg(metric = "ms")
@@ -133,22 +157,24 @@ module Sidekiq
         end
       end
 
-      class MarkResult < Struct.new(:time, :label)
-        def bucket
-          time.strftime("%H:%M")
-        end
+      MarkResult = Struct.new(:time, :label, :bucket)
+
+      def self.bkt_time_s(time, granularity)
+        # truncate time to ten minutes ("8:40", not "8:43") or one minute
+        truncation = (granularity == :hourly) ? 600 : 60
+        Time.at(time.to_i - time.to_i % truncation).utc.iso8601
       end
 
       private
 
-      def fetch_marks(time_range)
+      def fetch_marks(time_range, granularity)
         [].tap do |result|
           marks = @pool.with { |c| c.hgetall("#{@time.strftime("%Y%m%d")}-marks") }
 
           marks.each do |timestamp, label|
             time = Time.parse(timestamp)
             if time_range.cover? time
-              result << MarkResult.new(time, label)
+              result << MarkResult.new(time, label, Query.bkt_time_s(time, granularity))
             end
           end
         end

data/lib/sidekiq/metrics/shared.rb

@@ -25,7 +25,10 @@ module Sidekiq
     #
     # To store this data, we use Redis' BITFIELD command to store unsigned 16-bit counters
     # per bucket per klass per minute. It's unlikely that most people will be executing more
-    # than 1000 job/sec for a full minute of a specific type.
+    # than 1000 job/sec for a full minute of a specific type (i.e. overflow 65,536).
+    #
+    # Histograms are only stored at the fine-grained level, they are not rolled up
+    # for longer-term buckets.
     class Histogram
       include Enumerable
 

data/lib/sidekiq/metrics/tracking.rb

@@ -19,13 +19,13 @@ module Sidekiq
       end
 
       def track(queue, klass)
-        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
+        start = mono_ms
         time_ms = 0
         begin
           begin
             yield
           ensure
-            finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
+            finish = mono_ms
             time_ms = finish - start
           end
           # We don't track time for failed jobs as they can have very unpredictable
@@ -51,7 +51,7 @@ module Sidekiq
       end
 
       # LONG_TERM = 90 * 24 * 60 * 60
-      # MID_TERM = 7 * 24 * 60 * 60
+      MID_TERM = 3 * 24 * 60 * 60
       SHORT_TERM = 8 * 60 * 60
 
       def flush(time = Time.now)
@@ -62,8 +62,10 @@ module Sidekiq
 
         now = time.utc
         # nowdate = now.strftime("%Y%m%d")
-        # nowhour = now.strftime("%Y%m%d|%-H")
-        nowmin = now.strftime("%Y%m%d|%-H:%-M")
+        # "250214|8:4" is the 10 minute bucket for Feb 14 2025, 08:43
+        nowmid = now.strftime("%y%m%d|%-H:%M")[0..-2]
+        # "250214|8:43" is the 1 minute bucket for Feb 14 2025, 08:43
+        nowshort = now.strftime("%y%m%d|%-H:%M")
         count = 0
 
         redis do |conn|
@@ -81,8 +83,8 @@ module Sidekiq
           # daily or hourly rollups.
           [
             # ["j", jobs, nowdate, LONG_TERM],
-            # ["j", jobs, nowhour, MID_TERM],
-            ["j", jobs, nowmin, SHORT_TERM]
+            ["j", jobs, nowmid, MID_TERM],
+            ["j", jobs, nowshort, SHORT_TERM]
           ].each do |prefix, data, bucket, ttl|
             conn.pipelined do |xa|
               stats = "#{prefix}|#{bucket}"