sidekiq 6.4.2 → 6.5.12

data/lib/sidekiq/launcher.rb

@@ -3,11 +3,12 @@
 require "sidekiq/manager"
 require "sidekiq/fetch"
 require "sidekiq/scheduled"
+require "sidekiq/ring_buffer"
 
 module Sidekiq
   # The Launcher starts the Manager and Poller threads and provides the process heartbeat.
   class Launcher
-    include Util
+    include Sidekiq::Component
 
     STATS_TTL = 5 * 365 * 24 * 60 * 60 # 5 years
 
@@ -22,11 +23,11 @@ module Sidekiq
     attr_accessor :manager, :poller, :fetcher
 
     def initialize(options)
+      @config = options
       options[:fetch] ||= BasicFetch.new(options)
       @manager = Sidekiq::Manager.new(options)
-      @poller = Sidekiq::Scheduled::Poller.new
+      @poller = Sidekiq::Scheduled::Poller.new(options)
       @done = false
-      @options = options
     end
 
     def run
@@ -45,7 +46,7 @@ module Sidekiq
 
     # Shuts down this Sidekiq instance. Waits up to the deadline for all jobs to complete.
     def stop
-      deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + @options[:timeout]
+      deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + @config[:timeout]
 
       @done = true
       @manager.quiet
@@ -55,8 +56,8 @@ module Sidekiq
 
       # Requeue everything in case there was a thread which fetched a job while the process was stopped.
       # This call is a no-op in Sidekiq but necessary for Sidekiq Pro.
-      strategy = @options[:fetch]
-      strategy.bulk_requeue([], @options)
+      strategy = @config[:fetch]
+      strategy.bulk_requeue([], @config)
 
       clear_heartbeat
     end
@@ -74,16 +75,18 @@ module Sidekiq
         heartbeat
         sleep BEAT_PAUSE
       end
-      Sidekiq.logger.info("Heartbeat stopping...")
+      logger.info("Heartbeat stopping...")
     end
 
     def clear_heartbeat
+      flush_stats
+
       # Remove record from Redis since we are shutting down.
       # Note we don't stop the heartbeat thread; if the process
       # doesn't actually exit, it'll reappear in the Web UI.
-      Sidekiq.redis do |conn|
+      redis do |conn|
         conn.pipelined do |pipeline|
-          pipeline.srem("processes", identity)
+          pipeline.srem("processes", [identity])
           pipeline.unlink("#{identity}:work")
         end
       end
@@ -97,7 +100,7 @@ module Sidekiq
       ❤
     end
 
-    def self.flush_stats
+    def flush_stats
       fails = Processor::FAILURE.reset
       procd = Processor::PROCESSED.reset
       return if fails + procd == 0
@@ -121,7 +124,6 @@ module Sidekiq
         Sidekiq.logger.warn("Unable to flush stats: #{ex}")
       end
     end
-    at_exit(&method(:flush_stats))
 
     def ❤
       key = identity
@@ -134,7 +136,7 @@ module Sidekiq
 
         nowdate = Time.now.utc.strftime("%Y-%m-%d")
 
-        Sidekiq.redis do |conn|
+        redis do |conn|
           conn.multi do |transaction|
             transaction.incrby("stat:processed", procd)
             transaction.incrby("stat:processed:#{nowdate}", procd)
@@ -161,15 +163,15 @@ module Sidekiq
         fails = procd = 0
         kb = memory_usage(::Process.pid)
 
-        _, exists, _, _, msg = Sidekiq.redis { |conn|
+        _, exists, _, _, msg = redis { |conn|
           conn.multi { |transaction|
-            transaction.sadd("processes", key)
+            transaction.sadd("processes", [key])
             transaction.exists?(key)
             transaction.hmset(key, "info", to_json,
               "busy", curstate.size,
               "beat", Time.now.to_f,
               "rtt_us", rtt,
-              "quiet", @done,
+              "quiet", @done.to_s,
               "rss", kb)
             transaction.expire(key, 60)
             transaction.rpop("#{key}-signals")
@@ -178,6 +180,7 @@ module Sidekiq
 
         # first heartbeat or recovering from an outage and need to reestablish our heartbeat
         fire_event(:heartbeat) unless exists
+        fire_event(:beat, oneshot: false)
 
         return unless msg
 
@@ -199,7 +202,7 @@ module Sidekiq
 
     def check_rtt
       a = b = 0
-      Sidekiq.redis do |x|
+      redis do |x|
         a = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
         x.ping
         b = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
@@ -210,7 +213,7 @@ module Sidekiq
       # Workable is < 10,000µs
       # Log a warning if it's a disaster.
       if RTT_READINGS.all? { |x| x > RTT_WARNING_LEVEL }
-        Sidekiq.logger.warn <<~EOM
+        logger.warn <<~EOM
           Your Redis network connection is performing extremely poorly.
           Last RTT readings were #{RTT_READINGS.buffer.inspect}, ideally these should be < 1000.
           Ensure Redis is running in the same AZ or datacenter as Sidekiq.
@@ -247,10 +250,10 @@ module Sidekiq
         "hostname" => hostname,
         "started_at" => Time.now.to_f,
         "pid" => ::Process.pid,
-        "tag" => @options[:tag] || "",
-        "concurrency" => @options[:concurrency],
-        "queues" => @options[:queues].uniq,
-        "labels" => @options[:labels],
+        "tag" => @config[:tag] || "",
+        "concurrency" => @config[:concurrency],
+        "queues" => @config[:queues].uniq,
+        "labels" => @config[:labels],
         "identity" => identity
       }
     end

data/lib/sidekiq/logger.rb

@@ -18,7 +18,7 @@ module Sidekiq
     end
 
     def self.add(k, v)
-      Thread.current[:sidekiq_context][k] = v
+      current[k] = v
     end
   end
 

data/lib/sidekiq/manager.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "sidekiq/util"
 require "sidekiq/processor"
 require "sidekiq/fetch"
 require "set"
@@ -21,29 +20,26 @@ module Sidekiq
   # the shutdown process.  The other tasks are performed by other threads.
   #
   class Manager
-    include Util
+    include Sidekiq::Component
 
     attr_reader :workers
-    attr_reader :options
 
     def initialize(options = {})
+      @config = options
       logger.debug { options.inspect }
-      @options = options
       @count = options[:concurrency] || 10
       raise ArgumentError, "Concurrency of #{@count} is not supported" if @count < 1
 
       @done = false
       @workers = Set.new
       @count.times do
-        @workers << Processor.new(self, options)
+        @workers << Processor.new(@config, &method(:processor_result))
       end
       @plock = Mutex.new
     end
 
     def start
-      @workers.each do |x|
-        x.start
-      end
+      @workers.each(&:start)
     end
 
     def quiet
@@ -51,7 +47,7 @@ module Sidekiq
       @done = true
 
       logger.info { "Terminating quiet threads" }
-      @workers.each { |x| x.terminate }
+      @workers.each(&:terminate)
       fire_event(:quiet, reverse: true)
     end
 
@@ -72,17 +68,11 @@ module Sidekiq
       hard_shutdown
     end
 
-    def processor_stopped(processor)
-      @plock.synchronize do
-        @workers.delete(processor)
-      end
-    end
-
-    def processor_died(processor, reason)
+    def processor_result(processor, reason = nil)
       @plock.synchronize do
         @workers.delete(processor)
         unless @done
-          p = Processor.new(self, options)
+          p = Processor.new(@config, &method(:processor_result))
           @workers << p
           p.start
         end
@@ -107,7 +97,7 @@ module Sidekiq
         jobs = cleanup.map { |p| p.job }.compact
 
         logger.warn { "Terminating #{cleanup.size} busy threads" }
-        logger.warn { "Jobs still in progress #{jobs.inspect}" }
+        logger.debug { "Jobs still in progress #{jobs.inspect}" }
 
         # Re-enqueue unfinished jobs
         # NOTE: You may notice that we may push a job back to redis before
@@ -115,8 +105,8 @@ module Sidekiq
         # contract says that jobs are run AT LEAST once. Process termination
         # is delayed until we're certain the jobs are back in Redis because
         # it is worse to lose a job than to run it twice.
-        strategy = @options[:fetch]
-        strategy.bulk_requeue(jobs, @options)
+        strategy = @config[:fetch]
+        strategy.bulk_requeue(jobs, @config)
       end
 
       cleanup.each do |processor|
@@ -129,5 +119,18 @@ module Sidekiq
       deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + 3
       wait_for(deadline) { @workers.empty? }
     end
+
+    # hack for quicker development / testing environment #2774
+    PAUSE_TIME = $stdout.tty? ? 0.1 : 0.5
+
+    # Wait for the orblock to be true or the deadline passed.
+    def wait_for(deadline, &condblock)
+      remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      while remaining > PAUSE_TIME
+        return if condblock.call
+        sleep PAUSE_TIME
+        remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+    end
   end
 end

data/lib/sidekiq/metrics/deploy.rb

@@ -0,0 +1,47 @@
+require "sidekiq"
+require "time"
+
+# This file is designed to be required within the user's
+# deployment script; it should need a bare minimum of dependencies.
+#
+#   require "sidekiq/metrics/deploy"
+#   gitdesc = `git log -1 --format="%h %s"`.strip
+#   d = Sidekiq::Metrics::Deploy.new
+#   d.mark(label: gitdesc)
+#
+# Note that you cannot mark more than once per minute. This is a feature, not a bug.
+module Sidekiq
+  module Metrics
+    class Deploy
+      MARK_TTL = 90 * 24 * 60 * 60 # 90 days
+
+      def initialize(pool = Sidekiq.redis_pool)
+        @pool = pool
+      end
+
+      def mark(at: Time.now, label: "")
+        # we need to round the timestamp so that we gracefully
+        # handle an excepted common error in marking deploys:
+        # having every process mark its deploy, leading
+        # to N marks for each deploy. Instead we round the time
+        # to the minute so that multple marks within that minute
+        # will all naturally rollup into one mark per minute.
+        whence = at.utc
+        floor = Time.utc(whence.year, whence.month, whence.mday, whence.hour, whence.min, 0)
+        datecode = floor.strftime("%Y%m%d")
+        key = "#{datecode}-marks"
+        @pool.with do |c|
+          c.pipelined do |pipe|
+            pipe.hsetnx(key, floor.iso8601, label)
+            pipe.expire(key, MARK_TTL)
+          end
+        end
+      end
+
+      def fetch(date = Time.now.utc.to_date)
+        datecode = date.strftime("%Y%m%d")
+        @pool.with { |c| c.hgetall("#{datecode}-marks") }
+      end
+    end
+  end
+end

data/lib/sidekiq/metrics/query.rb

@@ -0,0 +1,153 @@
+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
+      def initialize(pool: Sidekiq.redis_pool, now: Time.now)
+        @time = now.utc
+        @pool = pool
+        @klass = nil
+      end
+
+      # Get metric data for all jobs from the last hour
+      def top_jobs(minutes: 60)
+        result = Result.new
+
+        time = @time
+        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}"
+              pipe.hgetall key
+              result.prepend_bucket time
+              time -= 60
+            end
+          end
+        end
+
+        time = @time
+        redis_results.each do |hash|
+          hash.each do |k, v|
+            kls, metric = k.split("|")
+            result.job_results[kls].add_metric metric, time, v.to_i
+          end
+          time -= 60
+        end
+
+        result.marks = fetch_marks(result.starts_at..result.ends_at)
+
+        result
+      end
+
+      def for_job(klass, minutes: 60)
+        result = Result.new
+
+        time = @time
+        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}"
+              pipe.hmget key, "#{klass}|ms", "#{klass}|p", "#{klass}|f"
+              result.prepend_bucket time
+              time -= 60
+            end
+          end
+        end
+
+        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)
+            time -= 60
+          end
+        end
+
+        result.marks = fetch_marks(result.starts_at..result.ends_at)
+
+        result
+      end
+
+      class Result < Struct.new(:starts_at, :ends_at, :size, :buckets, :job_results, :marks)
+        def initialize
+          super
+          self.buckets = []
+          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
+        end
+      end
+
+      class JobResult < Struct.new(:series, :hist, :totals)
+        def initialize
+          super
+          self.series = Hash.new { |h, k| h[k] = Hash.new(0) }
+          self.hist = Hash.new { |h, k| h[k] = [] }
+          self.totals = Hash.new(0)
+        end
+
+        def add_metric(metric, time, value)
+          totals[metric] += value
+          series[metric][time.strftime("%H:%M")] += 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
+        end
+
+        def total_avg(metric = "ms")
+          completed = totals["p"] - totals["f"]
+          totals[metric].to_f / completed
+        end
+
+        def series_avg(metric = "ms")
+          series[metric].each_with_object(Hash.new(0)) do |(bucket, value), result|
+            completed = series.dig("p", bucket) - series.dig("f", bucket)
+            result[bucket] = (completed == 0) ? 0 : value.to_f / completed
+          end
+        end
+      end
+
+      class MarkResult < Struct.new(:time, :label)
+        def bucket
+          time.strftime("%H:%M")
+        end
+      end
+
+      private
+
+      def fetch_marks(time_range)
+        [].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)
+            end
+          end
+        end
+      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