sidekiq 7.1.4 → 8.0.9

data/lib/sidekiq/job_retry.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "zlib"
-require "base64"
 require "sidekiq/component"
 
 module Sidekiq
@@ -60,8 +59,13 @@ module Sidekiq
   #    end
   #
   class JobRetry
+    # Handled means the job failed but has been dealt with
+    # (by creating a retry, rescheduling it, etc). It still
+    # needs to be logged and dispatched to error_handlers.
     class Handled < ::RuntimeError; end
 
+    # Skip means the job failed but Sidekiq does not need to
+    # create a retry, log it or send to error_handlers.
     class Skip < Handled; end
 
     include Sidekiq::Component
@@ -130,11 +134,15 @@ module Sidekiq
       process_retry(jobinst, msg, queue, e)
       # We've handled this error associated with this job, don't
       # need to handle it at the global level
-      raise Skip
+      raise Handled
     end
 
     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.
@@ -145,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
 
@@ -173,19 +181,21 @@ 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
       when :discard
-        return # poof!
+        msg["discarded_at"] = now_ms
+
+        return run_death_handlers(msg, exception)
       when :kill
         return retries_exhausted(jobinst, msg, exception)
       end
 
       # 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|
@@ -193,6 +203,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
@@ -226,7 +244,7 @@ module Sidekiq
     end
 
     def retries_exhausted(jobinst, msg, exception)
-      begin
+      rv = begin
         block = jobinst&.sidekiq_retries_exhausted_block
 
         # the sidekiq_retries_exhausted_block can be defined in a wrapped class (ActiveJob for instance)
@@ -239,12 +257,22 @@ module Sidekiq
         handle_exception(e, {context: "Error calling retries_exhausted", job: msg})
       end
 
-      send_to_morgue(msg) unless msg["dead"] == false
+      discarded = msg["dead"] == false || rv == :discard
+
+      if discarded
+        msg["discarded_at"] = now_ms
+      else
+        send_to_morgue(msg)
+      end
+
+      run_death_handlers(msg, exception)
+    end
 
+    def run_death_handlers(job, exception)
       @capsule.config.death_handlers.each do |handler|
-        handler.call(msg, exception)
+        handler.call(job, exception)
       rescue => e
-        handle_exception(e, {context: "Error calling death handler", job: msg})
+        handle_exception(e, {context: "Error calling death handler", job: job})
       end
     end
 
@@ -294,7 +322,7 @@ module Sidekiq
     def compress_backtrace(backtrace)
       serialized = Sidekiq.dump_json(backtrace)
       compressed = Zlib::Deflate.deflate(serialized)
-      Base64.encode64(compressed)
+      [compressed].pack("m0") # Base64.strict_encode64
     end
   end
 end

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
 
@@ -141,19 +142,27 @@ module Sidekiq
       key = identity
       fails = procd = 0
 
+      idle = config[:reap_connections]
+      if idle
+        config.capsules.each_value { |cap| cap.local_redis_pool.reap(idle, &:close) }
+        config.local_redis_pool.reap(idle, &:close)
+      end
+
       begin
         flush_stats
 
         curstate = Processor::WORK_STATE.dup
+        curstate.transform_values! { |val| Sidekiq.dump_json(val) }
+
         redis do |conn|
           # work is the current set of executing jobs
           work_key = "#{key}:work"
-          conn.pipelined do |transaction|
+          conn.multi do |transaction|
             transaction.unlink(work_key)
-            curstate.each_pair do |tid, hash|
-              transaction.hset(work_key, tid, Sidekiq.dump_json(hash))
+            if curstate.size > 0
+              transaction.hset(work_key, curstate)
+              transaction.expire(work_key, 60)
             end
-            transaction.expire(work_key, 60)
           end
         end
 
@@ -249,8 +258,15 @@ module Sidekiq
         "pid" => ::Process.pid,
         "tag" => @config[:tag] || "",
         "concurrency" => @config.total_concurrency,
+        "capsules" => @config.capsules.each_with_object({}) { |(name, cap), memo|
+          memo[name] = cap.to_h
+        },
+        #####
+        # TODO deprecated, remove in 9.0
+        # This data is now found in the `capsules` element above
         "queues" => @config.capsules.values.flat_map { |cap| cap.queues }.uniq,
-        "weights" => to_weights,
+        "weights" => @config.capsules.values.map(&:weights),
+        #####
         "labels" => @config[:labels].to_a,
         "identity" => identity,
         "version" => Sidekiq::VERSION,
@@ -258,10 +274,6 @@ module Sidekiq
       }
     end
 
-    def to_weights
-      @config.capsules.values.map(&:weights)
-    end
-
     def to_json
       # this data changes infrequently so dump it to a string
       # now so we don't need to dump it every heartbeat.

data/lib/sidekiq/loader.rb

@@ -0,0 +1,57 @@
+module Sidekiq
+  require "sidekiq/component"
+
+  class Loader
+    include Sidekiq::Component
+
+    def initialize(cfg = Sidekiq.default_configuration)
+      @config = cfg
+      @load_hooks = Hash.new { |h, k| h[k] = [] }
+      @loaded = Set.new
+      @lock = Mutex.new
+    end
+
+    # Declares a block that will be executed when a Sidekiq component is fully
+    # loaded. If the component has already loaded, the block is executed
+    # immediately.
+    #
+    #   Sidekiq.loader.on_load(:api) do
+    #     # extend the sidekiq API
+    #   end
+    #
+    def on_load(name, &block)
+      # we don't want to hold the lock while calling the block
+      to_run = nil
+
+      @lock.synchronize do
+        if @loaded.include?(name)
+          to_run = block
+        else
+          @load_hooks[name] << block
+        end
+      end
+
+      to_run&.call
+      nil
+    end
+
+    # Executes all blocks registered to +name+ via on_load.
+    #
+    #   Sidekiq.loader.run_load_hooks(:api)
+    #
+    # In the case of the above example, it will execute all hooks registered for +:api+.
+    #
+    def run_load_hooks(name)
+      hks = @lock.synchronize do
+        @loaded << name
+        @load_hooks.delete(name)
+      end
+
+      hks&.each do |blk|
+        blk.call
+      rescue => ex
+        handle_exception(ex, hook: name)
+      end
+    end
+  end
+end

data/lib/sidekiq/logger.rb

@@ -22,92 +22,48 @@ 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
       class Base < ::Logger::Formatter
+        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
+        }
+
         def tid
           Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
         end
 
-        def ctx
-          Sidekiq::Context.current
+        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
 
-        def format_context
-          if ctx.any?
-            " " + ctx.compact.map { |k, v|
-              case v
-              when Array
-                "#{k}=#{v.join(",")}"
-              else
-                "#{k}=#{v}"
-              end
-            }.join(" ")
-          end
+      class Pretty < Base
+        def call(severity, time, program_name, message)
+          "#{COLORS[severity]} #{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
         end
       end
 
-      class Pretty < Base
+      class Plain < Base
         def call(severity, time, program_name, message)
-          "#{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context} #{severity}: #{message}\n"
+          "#{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"
+          "#{COLORS[severity]} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
         end
       end
 
@@ -120,7 +76,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,7 +1,7 @@
-require "sidekiq"
-require "date"
-require "set"
+# frozen_string_literal: true
 
+require "date"
+require "sidekiq"
 require "sidekiq/metrics/shared"
 
 module Sidekiq
@@ -10,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)
@@ -19,85 +19,113 @@ module Sidekiq
         @klass = nil
       end
 
-      # Get metric data for all jobs from the last hour
-      def top_jobs(minutes: 60)
-        result = Result.new
+      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
+      #  +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|
             kls, metric = k.split("|")
+            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)
@@ -105,18 +133,19 @@ 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")
           completed = totals["p"] - totals["f"]
+          return 0 if completed.zero?
           totals[metric].to_f / completed
         end
 
@@ -128,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