sidekiq 6.5.1 → 6.5.2

data/lib/sidekiq/metrics/query.rb

@@ -0,0 +1,124 @@
+require "sidekiq"
+require "date"
+require "set"
+
+require "sidekiq/metrics/shared"
+
+module Sidekiq
+  module Metrics
+    # Allows caller to query for Sidekiq execution metrics within Redis.
+    # 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
+    # support timezones.
+    class Query
+      # :hour, :day, :month
+      attr_accessor :period
+
+      # a specific job class, e.g. "App::OrderJob"
+      attr_accessor :klass
+
+      # the date specific to the period
+      # for :day or :hour, something like Date.today or Date.new(2022, 7, 13)
+      # for :month, Date.new(2022, 7, 1)
+      attr_accessor :date
+
+      # for period = :hour, the specific hour, integer e.g. 1 or 18
+      # note that hours and minutes do not have a leading zero so minute-specific
+      # keys will look like "j|20220718|7:3" for data at 07:03.
+      attr_accessor :hour
+
+      def initialize(pool: Sidekiq.redis_pool, now: Time.now)
+        @time = now.utc
+        @pool = pool
+        @klass = nil
+      end
+
+      # Get metric data from the last hour and roll it up
+      # into top processed count and execution time based on class.
+      def top_jobs
+        resultset = {}
+        resultset[:date] = @time.to_date
+        resultset[:period] = :hour
+        resultset[:ends_at] = @time
+        time = @time
+
+        results = @pool.with do |conn|
+          conn.pipelined do |pipe|
+            resultset[:size] = 60
+            60.times do |idx|
+              key = "j|#{time.strftime("%Y%m%d")}|#{time.hour}:#{time.min}"
+              pipe.hgetall key
+              time -= 60
+            end
+            resultset[:starts_at] = time
+          end
+        end
+
+        t = Hash.new(0)
+        klsset = Set.new
+        # merge the per-minute data into a totals hash for the hour
+        results.each do |hash|
+          hash.each { |k, v| t[k] = t[k] + v.to_i }
+          klsset.merge(hash.keys.map { |k| k.split("|")[0] })
+        end
+        resultset[:job_classes] = klsset.delete_if { |item| item.size < 3 }
+        resultset[:totals] = t
+        top = t.each_with_object({}) do |(k, v), memo|
+          (kls, metric) = k.split("|")
+          memo[metric] ||= Hash.new(0)
+          memo[metric][kls] = v
+        end
+
+        sorted = {}
+        top.each_pair do |metric, hash|
+          sorted[metric] = hash.sort_by { |k, v| v }.reverse.to_h
+        end
+        resultset[:top_classes] = sorted
+        resultset
+      end
+
+      def for_job(klass)
+        resultset = {}
+        resultset[:date] = @time.to_date
+        resultset[:period] = :hour
+        resultset[:ends_at] = @time
+        marks = @pool.with { |c| c.hgetall("#{@time.strftime("%Y%m%d")}-marks") }
+
+        time = @time
+        initial = @pool.with do |conn|
+          conn.pipelined do |pipe|
+            resultset[:size] = 60
+            60.times do |idx|
+              key = "j|#{time.strftime("%Y%m%d|%-H:%-M")}"
+              pipe.hmget key, "#{klass}|ms", "#{klass}|p", "#{klass}|f"
+              time -= 60
+            end
+          end
+        end
+
+        time = @time
+        hist = Histogram.new(klass)
+        results = @pool.with do |conn|
+          initial.map do |(ms, p, f)|
+            tm = Time.utc(time.year, time.month, time.mday, time.hour, time.min, 0)
+            {
+              time: tm.iso8601,
+              epoch: tm.to_i,
+              ms: ms.to_i, p: p.to_i, f: f.to_i, hist: hist.fetch(conn, time)
+            }.tap { |x|
+              x[:mark] = marks[x[:time]] if marks[x[:time]]
+              time -= 60
+            }
+          end
+        end
+
+        resultset[:marks] = marks
+        resultset[:starts_at] = time
+        resultset[:data] = results
+        resultset
+      end
+    end
+  end
+end

data/lib/sidekiq/metrics/shared.rb

@@ -0,0 +1,94 @@
+require "concurrent"
+
+module Sidekiq
+  module Metrics
+    # TODO Support apps without concurrent-ruby
+    Counter = ::Concurrent::AtomicFixnum
+
+    # Implements space-efficient but statistically useful histogram storage.
+    # A precise time histogram stores every time. Instead we break times into a set of
+    # known buckets and increment counts of the associated time bucket. Even if we call
+    # the histogram a million times, we'll still only store 26 buckets.
+    # NB: needs to be thread-safe or resiliant to races.
+    #
+    # 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.
+    class Histogram
+      include Enumerable
+
+      # This number represents the maximum milliseconds for this bucket.
+      # 20 means all job executions up to 20ms, e.g. if a job takes
+      # 280ms, it'll increment bucket[7]. Note we can track job executions
+      # up to about 5.5 minutes. After that, it's assumed you're probably
+      # not too concerned with its performance.
+      BUCKET_INTERVALS = [
+        20, 30, 45, 65, 100,
+        150, 225, 335, 500, 750,
+        1100, 1700, 2500, 3800, 5750,
+        8500, 13000, 20000, 30000, 45000,
+        65000, 100000, 150000, 225000, 335000,
+        Float::INFINITY # the "maybe your job is too long" bucket
+      ]
+      LABELS = [
+        "20ms", "30ms", "45ms", "65ms", "100ms",
+        "150ms", "225ms", "335ms", "500ms", "750ms",
+        "1.1s", "1.7s", "2.5s", "3.8s", "5.75s",
+        "8.5s", "13s", "20s", "30s", "45s",
+        "65s", "100s", "150s", "225s", "335s",
+        "Slow"
+      ]
+
+      FETCH = "GET u16 #0 GET u16 #1 GET u16 #2 GET u16 #3 \
+        GET u16 #4 GET u16 #5 GET u16 #6 GET u16 #7 \
+        GET u16 #8 GET u16 #9 GET u16 #10 GET u16 #11 \
+        GET u16 #12 GET u16 #13 GET u16 #14 GET u16 #15 \
+        GET u16 #16 GET u16 #17 GET u16 #18 GET u16 #19 \
+        GET u16 #20 GET u16 #21 GET u16 #22 GET u16 #23 \
+        GET u16 #24 GET u16 #25".split
+
+      def each
+        buckets.each { |counter| yield counter.value }
+      end
+
+      def label(idx)
+        LABELS[idx]
+      end
+
+      attr_reader :buckets
+      def initialize(klass)
+        @klass = klass
+        @buckets = Array.new(BUCKET_INTERVALS.size) { Counter.new }
+      end
+
+      def record_time(ms)
+        index_to_use = BUCKET_INTERVALS.each_index do |idx|
+          break idx if ms < BUCKET_INTERVALS[idx]
+        end
+
+        @buckets[index_to_use].increment
+      end
+
+      def fetch(conn, now = Time.now)
+        window = now.utc.strftime("%d-%H:%-M")
+        key = "#{@klass}-#{window}"
+        conn.bitfield(key, *FETCH)
+      end
+
+      def persist(conn, now = Time.now)
+        buckets, @buckets = @buckets, []
+        window = now.utc.strftime("%d-%H:%-M")
+        key = "#{@klass}-#{window}"
+        cmd = [key, "OVERFLOW", "SAT"]
+        buckets.each_with_index do |counter, idx|
+          val = counter.value
+          cmd << "INCRBY" << "u16" << "##{idx}" << val.to_s if val > 0
+        end
+
+        conn.bitfield(*cmd) if cmd.size > 3
+        conn.expire(key, 86400)
+        key
+      end
+    end
+  end
+end

data/lib/sidekiq/metrics/tracking.rb

@@ -0,0 +1,134 @@
+require "time"
+require "sidekiq"
+require "sidekiq/metrics/shared"
+
+# This file contains the components which track execution metrics within Sidekiq.
+module Sidekiq
+  module Metrics
+    class ExecutionTracker
+      include Sidekiq::Component
+
+      def initialize(config)
+        @config = config
+        @jobs = Hash.new(0)
+        @totals = Hash.new(0)
+        @grams = Hash.new { |hash, key| hash[key] = Histogram.new(key) }
+        @lock = Mutex.new
+      end
+
+      def track(queue, klass)
+        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
+        time_ms = 0
+        begin
+          begin
+            yield
+          ensure
+            finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
+            time_ms = finish - start
+          end
+          # We don't track time for failed jobs as they can have very unpredictable
+          # execution times. more important to know average time for successful jobs so we
+          # can better recognize when a perf regression is introduced.
+          @lock.synchronize {
+            @grams[klass].record_time(time_ms)
+            @jobs["#{klass}|ms"] += time_ms
+            @totals["ms"] += time_ms
+          }
+        rescue Exception
+          @lock.synchronize {
+            @jobs["#{klass}|f"] += 1
+            @totals["f"] += 1
+          }
+          raise
+        ensure
+          @lock.synchronize {
+            @jobs["#{klass}|p"] += 1
+            @totals["p"] += 1
+          }
+        end
+      end
+
+      LONG_TERM = 90 * 24 * 60 * 60
+      MID_TERM = 7 * 24 * 60 * 60
+      SHORT_TERM = 8 * 60 * 60
+
+      def flush(time = Time.now)
+        totals, jobs, grams = reset
+        procd = totals["p"]
+        fails = totals["f"]
+        return if procd == 0 && fails == 0
+
+        now = time.utc
+        nowdate = now.strftime("%Y%m%d")
+        nowhour = now.strftime("%Y%m%d|%-H")
+        nowmin = now.strftime("%Y%m%d|%-H:%-M")
+        count = 0
+
+        redis do |conn|
+          if grams.size > 0
+            conn.pipelined do |pipe|
+              grams.each do |_, gram|
+                gram.persist(pipe, now)
+              end
+            end
+          end
+
+          [
+            ["j", jobs, nowdate, LONG_TERM],
+            ["j", jobs, nowhour, MID_TERM],
+            ["j", jobs, nowmin, SHORT_TERM]
+          ].each do |prefix, data, bucket, ttl|
+            # Quietly seed the new 7.0 stats format so migration is painless.
+            conn.pipelined do |xa|
+              stats = "#{prefix}|#{bucket}"
+              # logger.debug "Flushing metrics #{stats}"
+              data.each_pair do |key, value|
+                xa.hincrby stats, key, value
+                count += 1
+              end
+              xa.expire(stats, ttl)
+            end
+          end
+          logger.info "Flushed #{count} metrics"
+          count
+        end
+      end
+
+      private
+
+      def reset
+        @lock.synchronize {
+          array = [@totals, @jobs, @grams]
+          @totals = Hash.new(0)
+          @jobs = Hash.new(0)
+          @grams = Hash.new { |hash, key| hash[key] = Histogram.new(key) }
+          array
+        }
+      end
+    end
+
+    class Middleware
+      include Sidekiq::ServerMiddleware
+
+      def initialize(options)
+        @exec = options
+      end
+
+      def call(_instance, hash, queue, &block)
+        @exec.track(queue, hash["wrapped"] || hash["class"], &block)
+      end
+    end
+  end
+end
+
+if ENV["SIDEKIQ_METRICS_BETA"] == "1"
+  Sidekiq.configure_server do |config|
+    exec = Sidekiq::Metrics::ExecutionTracker.new(config)
+    config.server_middleware do |chain|
+      chain.add Sidekiq::Metrics::Middleware, exec
+    end
+    config.on(:beat) do
+      exec.flush
+    end
+  end
+end

data/lib/sidekiq/middleware/chain.rb

@@ -4,84 +4,98 @@ require "sidekiq/middleware/modules"
 
 module Sidekiq
   # Middleware is code configured to run before/after
-  # a message is processed.  It is patterned after Rack
+  # a job is processed.  It is patterned after Rack
   # middleware. Middleware exists for the client side
   # (pushing jobs onto the queue) as well as the server
   # side (when jobs are actually processed).
   #
+  # Callers will register middleware Classes and Sidekiq will
+  # create new instances of the middleware for every job. This
+  # is important so that instance state is not shared accidentally
+  # between job executions.
+  #
   # To add middleware for the client:
   #
-  # Sidekiq.configure_client do |config|
-  #   config.client_middleware do |chain|
-  #     chain.add MyClientHook
+  #   Sidekiq.configure_client do |config|
+  #     config.client_middleware do |chain|
+  #       chain.add MyClientHook
+  #     end
   #   end
-  # end
   #
   # To modify middleware for the server, just call
   # with another block:
   #
-  # Sidekiq.configure_server do |config|
-  #   config.server_middleware do |chain|
-  #     chain.add MyServerHook
-  #     chain.remove ActiveRecord
+  #   Sidekiq.configure_server do |config|
+  #     config.server_middleware do |chain|
+  #       chain.add MyServerHook
+  #       chain.remove ActiveRecord
+  #     end
   #   end
-  # end
   #
   # To insert immediately preceding another entry:
   #
-  # Sidekiq.configure_client do |config|
-  #   config.client_middleware do |chain|
-  #     chain.insert_before ActiveRecord, MyClientHook
+  #   Sidekiq.configure_client do |config|
+  #     config.client_middleware do |chain|
+  #       chain.insert_before ActiveRecord, MyClientHook
+  #     end
   #   end
-  # end
   #
   # To insert immediately after another entry:
   #
-  # Sidekiq.configure_client do |config|
-  #   config.client_middleware do |chain|
-  #     chain.insert_after ActiveRecord, MyClientHook
+  #   Sidekiq.configure_client do |config|
+  #     config.client_middleware do |chain|
+  #       chain.insert_after ActiveRecord, MyClientHook
+  #     end
   #   end
-  # end
   #
   # This is an example of a minimal server middleware:
   #
-  # class MyServerHook
-  #   include Sidekiq::ServerMiddleware
-  #   def call(job_instance, msg, queue)
-  #     logger.info "Before job"
-  #     redis {|conn| conn.get("foo") } # do something in Redis
-  #     yield
-  #     logger.info "After job"
+  #   class MyServerHook
+  #     include Sidekiq::ServerMiddleware
+  #
+  #     def call(job_instance, msg, queue)
+  #       logger.info "Before job"
+  #       redis {|conn| conn.get("foo") } # do something in Redis
+  #       yield
+  #       logger.info "After job"
+  #     end
   #   end
-  # end
   #
   # This is an example of a minimal client middleware, note
   # the method must return the result or the job will not push
   # to Redis:
   #
-  # class MyClientHook
-  #   include Sidekiq::ClientMiddleware
-  #   def call(job_class, msg, queue, redis_pool)
-  #     logger.info "Before push"
-  #     result = yield
-  #     logger.info "After push"
-  #     result
+  #   class MyClientHook
+  #     include Sidekiq::ClientMiddleware
+  #
+  #     def call(job_class, msg, queue, redis_pool)
+  #       logger.info "Before push"
+  #       result = yield
+  #       logger.info "After push"
+  #       result
+  #     end
   #   end
-  # end
   #
   module Middleware
     class Chain
       include Enumerable
 
+      # A unique instance of the middleware chain is created for
+      # each job executed in order to be thread-safe.
+      # @param copy [Sidekiq::Middleware::Chain] New instance of Chain
+      # @returns nil
       def initialize_copy(copy)
         copy.instance_variable_set(:@entries, entries.dup)
+        nil
       end
 
+      # Iterate through each middleware in the chain
       def each(&block)
         entries.each(&block)
       end
 
-      def initialize(config = nil)
+      # @api private
+      def initialize(config = nil) # :nodoc:
         @config = config
         @entries = nil
         yield self if block_given?
@@ -91,20 +105,33 @@ module Sidekiq
         @entries ||= []
       end
 
+      # Remove all middleware matching the given Class
+      # @param klass [Class]
       def remove(klass)
         entries.delete_if { |entry| entry.klass == klass }
       end
 
+      # Add the given middleware to the end of the chain.
+      # Sidekiq will call `klass.new(*args)` to create a clean
+      # copy of your middleware for every job executed.
+      #
+      #   chain.add(Statsd::Metrics, { collector: "localhost:8125" })
+      #
+      # @param klass [Class] Your middleware class
+      # @param *args [Array<Object>] Set of arguments to pass to every instance of your middleware
       def add(klass, *args)
         remove(klass)
         entries << Entry.new(@config, klass, *args)
       end
 
+      # Identical to {#add} except the middleware is added to the front of the chain.
       def prepend(klass, *args)
         remove(klass)
         entries.insert(0, Entry.new(@config, klass, *args))
       end
 
+      # Inserts +newklass+ before +oldklass+ in the chain.
+      # Useful if one middleware must run before another middleware.
       def insert_before(oldklass, newklass, *args)
         i = entries.index { |entry| entry.klass == newklass }
         new_entry = i.nil? ? Entry.new(@config, newklass, *args) : entries.delete_at(i)
@@ -112,6 +139,8 @@ module Sidekiq
         entries.insert(i, new_entry)
       end
 
+      # Inserts +newklass+ after +oldklass+ in the chain.
+      # Useful if one middleware must run after another middleware.
       def insert_after(oldklass, newklass, *args)
         i = entries.index { |entry| entry.klass == newklass }
         new_entry = i.nil? ? Entry.new(@config, newklass, *args) : entries.delete_at(i)
@@ -119,10 +148,12 @@ module Sidekiq
         entries.insert(i + 1, new_entry)
       end
 
+      # @return [Boolean] if the given class is already in the chain
       def exists?(klass)
         any? { |entry| entry.klass == klass }
       end
 
+      # @return [Boolean] if the chain contains no middleware
       def empty?
         @entries.nil? || @entries.empty?
       end
@@ -135,6 +166,8 @@ module Sidekiq
         entries.clear
       end
 
+      # Used by Sidekiq to execute the middleware at runtime
+      # @api private
       def invoke(*args)
         return yield if empty?
 
@@ -152,6 +185,8 @@ module Sidekiq
 
     private
 
+    # Represents each link in the middleware chain
+    # @api private
     class Entry
       attr_reader :klass
 

data/lib/sidekiq/middleware/current_attributes.rb

@@ -23,10 +23,12 @@ module Sidekiq
 
       def call(_, job, _, _)
         attrs = @klass.attributes
-        if job.has_key?("cattr")
-          job["cattr"].merge!(attrs)
-        else
-          job["cattr"] = attrs
+        if attrs.any?
+          if job.has_key?("cattr")
+            job["cattr"].merge!(attrs)
+          else
+            job["cattr"] = attrs
+          end
         end
         yield
       end

data/lib/sidekiq/processor.rb

@@ -174,7 +174,7 @@ module Sidekiq
         # signals that we created a retry successfully.  We can acknowlege the job.
         ack = true
         e = h.cause || h
-        handle_exception(e, {context: "Job raised exception", job: job_hash, jobstr: jobstr})
+        handle_exception(e, {context: "Job raised exception", job: job_hash})
         raise e
       rescue Exception => ex
         # Unexpected error!  This is very bad and indicates an exception that got past

data/lib/sidekiq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sidekiq
-  VERSION = "6.5.1"
+  VERSION = "6.5.2"
 end

data/lib/sidekiq/web/application.rb

@@ -60,6 +60,19 @@ module Sidekiq
       erb(:dashboard)
     end
 
+    get "/metrics" do
+      q = Sidekiq::Metrics::Query.new
+      @resultset = q.top_jobs
+      erb(:metrics)
+    end
+
+    get "/metrics/:name" do
+      @name = route_params[:name]
+      q = Sidekiq::Metrics::Query.new
+      @resultset = q.for_job(@name)
+      erb(:metrics_for_job)
+    end
+
     get "/busy" do
       erb(:busy)
     end

data/lib/sidekiq/web/helpers.rb

@@ -15,7 +15,7 @@ module Sidekiq
       # so extensions can be localized
       @strings[lang] ||= settings.locales.each_with_object({}) do |path, global|
         find_locale_files(lang).each do |file|
-          strs = YAML.load(File.open(file))
+          strs = YAML.safe_load(File.open(file))
           global.merge!(strs[lang])
         end
       end
@@ -148,6 +148,29 @@ module Sidekiq
       @processes ||= Sidekiq::ProcessSet.new
     end
 
+    # Sorts processes by hostname following the natural sort order so that
+    # 'worker.1' < 'worker.2' < 'worker.10' < 'worker.20'
+    # '2.1.1.1' < '192.168.0.2' < '192.168.0.10'
+    def sorted_processes
+      @sorted_processes ||= begin
+        return processes unless processes.all? { |p| p["hostname"] }
+
+        split_characters = /[._-]/
+
+        padding = processes.flat_map { |p| p["hostname"].split(split_characters) }.map(&:size).max
+
+        processes.to_a.sort_by do |process|
+          process["hostname"].split(split_characters).map do |substring|
+            # Left-pad the substring with '0' if it starts with a number or 'a'
+            # otherwise, so that '25' < 192' < 'a' ('025' < '192' < 'aaa')
+            padding_char = substring[0].match?(/\d/) ? "0" : "a"
+
+            substring.rjust(padding, padding_char)
+          end
+        end
+      end
+    end
+
     def stats
       @stats ||= Sidekiq::Stats.new
     end

data/lib/sidekiq/web.rb

@@ -33,6 +33,10 @@ module Sidekiq
       "Dead" => "morgue"
     }
 
+    if ENV["SIDEKIQ_METRICS_BETA"] == "1"
+      DEFAULT_TABS["Metrics"] = "metrics"
+    end
+
     class << self
       def settings
         self

data/lib/sidekiq.rb

@@ -34,7 +34,10 @@ module Sidekiq
       startup: [],
       quiet: [],
       shutdown: [],
-      heartbeat: []
+      # triggers when we fire the first heartbeat on startup OR repairing a network partition
+      heartbeat: [],
+      # triggers on EVERY heartbeat call, every 10 seconds
+      beat: []
     },
     dead_max_jobs: 10_000,
     dead_timeout_in_seconds: 180 * 24 * 60 * 60, # 6 months
@@ -84,6 +87,11 @@ module Sidekiq
     logger.warn(ex.backtrace.join("\n")) unless ex.backtrace.nil?
   end
 
+  # DEFAULT_ERROR_HANDLER is a constant that allows the default error handler to
+  # be referenced. It must be defined here, after the default_error_handler
+  # method is defined.
+  DEFAULT_ERROR_HANDLER = method(:default_error_handler)
+
   @config = DEFAULTS.dup
   def self.options
     logger.warn "`config.options[:key] = value` is deprecated, use `config[:key] = value`: #{caller(1..2)}"