sidekiq 7.3.9 → 8.0.8

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
 
@@ -82,15 +85,15 @@ module Sidekiq
       end
 
       def fetch(conn, now = Time.now)
-        window = now.utc.strftime("%d-%H:%-M")
-        key = "#{@klass}-#{window}"
+        window = now.utc.strftime("%-d-%-H:%-M")
+        key = "h|#{@klass}-#{window}"
         conn.bitfield_ro(key, *FETCH)
       end
 
       def persist(conn, now = Time.now)
         buckets, @buckets = @buckets, []
-        window = now.utc.strftime("%d-%H:%-M")
-        key = "#{@klass}-#{window}"
+        window = now.utc.strftime("%-d-%-H:%-M")
+        key = "h|#{@klass}-#{window}"
         cmd = [key, "OVERFLOW", "SAT"]
         buckets.each_with_index do |counter, idx|
           val = counter.value

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}"
@@ -145,4 +147,7 @@ Sidekiq.configure_server do |config|
   config.on(:beat) do
     exec.flush
   end
+  config.on(:exit) do
+    exec.flush
+  end
 end

data/lib/sidekiq/middleware/current_attributes.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_job/arguments"
 require "active_support/current_attributes"
 
 module Sidekiq
@@ -20,6 +21,8 @@ module Sidekiq
   #   Sidekiq::CurrentAttributes.persist(["Myapp::Current", "Myapp::OtherCurrent"])
   #
   module CurrentAttributes
+    Serializer = ::ActiveJob::Arguments
+
     class Save
       include Sidekiq::ClientMiddleware
 
@@ -33,26 +36,11 @@ module Sidekiq
             attrs = strklass.constantize.attributes
             # Retries can push the job N times, we don't
             # want retries to reset cattr. #5692, #5090
-            if attrs.any?
-              # Older rails has a bug that `CurrentAttributes#attributes` always returns
-              # the same hash instance. We need to dup it to avoid being accidentally mutated.
-              job[key] = if returns_same_object?
-                attrs.dup
-              else
-                attrs
-              end
-            end
+            job[key] = Serializer.serialize(attrs) if attrs.any?
           end
         end
         yield
       end
-
-      private
-
-      def returns_same_object?
-        ActiveSupport::VERSION::MAJOR < 8 ||
-          (ActiveSupport::VERSION::MAJOR == 8 && ActiveSupport::VERSION::MINOR == 0)
-      end
     end
 
     class Load
@@ -62,13 +50,13 @@ module Sidekiq
         @cattrs = cattrs
       end
 
-      def call(_, job, _, &block)
+      def call(_, job, *, &block)
         klass_attrs = {}
 
         @cattrs.each do |(key, strklass)|
           next unless job.has_key?(key)
 
-          klass_attrs[strklass.constantize] = job[key]
+          klass_attrs[strklass.constantize] = Serializer.deserialize(job[key]).to_h
         end
 
         wrap(klass_attrs.to_a, &block)
@@ -83,11 +71,14 @@ module Sidekiq
         retried = false
 
         begin
+          set_succeeded = false
           klass.set(attrs) do
+            set_succeeded = true
             wrap(klass_attrs, &block)
           end
         rescue NoMethodError
-          raise if retried
+          # Don't retry if the no method error didn't come from current attributes
+          raise if retried || set_succeeded
 
           # It is possible that the `CurrentAttributes` definition
           # was changed before the job started processing.
@@ -102,6 +93,7 @@ module Sidekiq
       def persist(klass_or_array, config = Sidekiq.default_configuration)
         cattrs = build_cattrs_hash(klass_or_array)
 
+        config.client_middleware.prepend Load, cattrs
         config.client_middleware.add Save, cattrs
         config.server_middleware.prepend Load, cattrs
       end

data/lib/sidekiq/paginator.rb

@@ -17,7 +17,14 @@ module Sidekiq
       ending = starting + page_size - 1
 
       Sidekiq.redis do |conn|
-        type = conn.type(key)
+        # horrible, think you can make this cleaner?
+        type = TYPE_CACHE[key]
+        if type
+        elsif key.start_with?("queue:")
+          type = TYPE_CACHE[key] = "list"
+        else
+          type = TYPE_CACHE[key] = conn.type(key)
+        end
         rev = opts && opts[:reverse]
 
         case type

data/lib/sidekiq/processor.rb

@@ -3,6 +3,7 @@
 require "sidekiq/fetch"
 require "sidekiq/job_logger"
 require "sidekiq/job_retry"
+require "sidekiq/profiler"
 
 module Sidekiq
   ##
@@ -66,7 +67,7 @@ module Sidekiq
       @thread ||= safe_thread("#{config.name}/processor", &method(:run))
     end
 
-    private unless $TESTING
+    private
 
     def run
       # By setting this thread-local, Sidekiq.redis will access +Sidekiq::Capsule#redis_pool+
@@ -112,13 +113,17 @@ module Sidekiq
     def handle_fetch_exception(ex)
       unless @down
         @down = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-        logger.error("Error fetching job: #{ex}")
         handle_exception(ex)
       end
       sleep(1)
       nil
     end
 
+    def profile(job, &block)
+      return yield unless job["profile"]
+      Sidekiq::Profiler.new(config).call(job, &block)
+    end
+
     def dispatch(job_hash, queue, jobstr)
       # since middleware can mutate the job hash
       # we need to clone it to report the original
@@ -132,17 +137,19 @@ module Sidekiq
         @retrier.global(jobstr, queue) do
           @job_logger.call(job_hash, queue) do
             stats(jobstr, queue) do
-              # Rails 5 requires a Reloader to wrap code execution.  In order to
-              # constantize the worker and instantiate an instance, we have to call
-              # the Reloader.  It handles code loading, db connection management, etc.
-              # Effectively this block denotes a "unit of work" to Rails.
-              @reloader.call do
-                klass = Object.const_get(job_hash["class"])
-                instance = klass.new
-                instance.jid = job_hash["jid"]
-                instance._context = self
-                @retrier.local(instance, jobstr, queue) do
-                  yield instance
+              profile(job_hash) do
+                # Rails 5 requires a Reloader to wrap code execution.  In order to
+                # constantize the worker and instantiate an instance, we have to call
+                # the Reloader.  It handles code loading, db connection management, etc.
+                # Effectively this block denotes a "unit of work" to Rails.
+                @reloader.call do
+                  klass = Object.const_get(job_hash["class"])
+                  instance = klass.new
+                  instance.jid = job_hash["jid"]
+                  instance._context = self
+                  @retrier.local(instance, jobstr, queue) do
+                    yield instance
+                  end
                 end
               end
             end
@@ -165,7 +172,6 @@ module Sidekiq
       begin
         job_hash = Sidekiq.load_json(jobstr)
       rescue => ex
-        handle_exception(ex, {context: "Invalid JSON for job", jobstr: jobstr})
         now = Time.now.to_f
         redis do |conn|
           conn.multi do |xa|
@@ -174,6 +180,7 @@ module Sidekiq
             xa.zremrangebyrank("dead", 0, - @capsule.config[:dead_max_jobs])
           end
         end
+        handle_exception(ex, {context: "Invalid JSON for job", jobstr: jobstr})
         return uow.acknowledge
       end
 

data/lib/sidekiq/profiler.rb

@@ -0,0 +1,72 @@
+require "fileutils"
+require "sidekiq/component"
+
+module Sidekiq
+  # Allows the user to profile jobs running in production.
+  # See details in the Profiling wiki page.
+  class Profiler
+    EXPIRY = 86400 # 1 day
+    DEFAULT_OPTIONS = {
+      mode: :wall
+    }
+
+    include Sidekiq::Component
+    def initialize(config)
+      @config = config
+      @vernier_output_dir = ENV.fetch("VERNIER_OUTPUT_DIR") { Dir.tmpdir }
+    end
+
+    def call(job, &block)
+      return yield unless job["profile"]
+
+      token = job["profile"]
+      type = job["class"]
+      jid = job["jid"]
+      started_at = Time.now
+
+      rundata = {
+        started_at: started_at.to_i,
+        token: token,
+        type: type,
+        jid: jid,
+        # .gz extension tells Vernier to compress the data
+        filename: File.join(
+          @vernier_output_dir,
+          "#{token}-#{type}-#{jid}-#{started_at.strftime("%Y%m%d-%H%M%S")}.json.gz"
+        )
+      }
+      profiler_options = profiler_options(job, rundata)
+
+      require "vernier"
+      begin
+        a = Time.now
+        rc = Vernier.profile(**profiler_options, &block)
+        b = Time.now
+
+        # Failed jobs will raise an exception on previous line and skip this
+        # block. Only successful jobs will persist profile data to Redis.
+        key = "#{token}-#{jid}"
+        data = File.read(rundata[:filename])
+        redis do |conn|
+          conn.multi do |m|
+            m.zadd("profiles", Time.now.to_f + EXPIRY, key)
+            m.hset(key, rundata.merge(elapsed: (b - a), data: data, size: data.bytesize))
+            m.expire(key, EXPIRY)
+          end
+        end
+        rc
+      ensure
+        FileUtils.rm_f(rundata[:filename])
+      end
+    end
+
+    private
+
+    def profiler_options(job, rundata)
+      profiler_options = (job["profiler_options"] || {}).transform_keys(&:to_sym)
+      profiler_options[:mode] = profiler_options[:mode].to_sym if profiler_options[:mode]
+
+      DEFAULT_OPTIONS.merge(profiler_options, {out: rundata[:filename]})
+    end
+  end
+end