sidekiq 6.5.12 → 7.3.7

data/lib/sidekiq/launcher.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require "sidekiq/manager"
-require "sidekiq/fetch"
+require "sidekiq/capsule"
 require "sidekiq/scheduled"
 require "sidekiq/ring_buffer"
 
 module Sidekiq
-  # The Launcher starts the Manager and Poller threads and provides the process heartbeat.
+  # The Launcher starts the Capsule Managers, the Poller thread and provides the process heartbeat.
   class Launcher
     include Sidekiq::Component
 
@@ -16,48 +16,56 @@ module Sidekiq
       proc { "sidekiq" },
       proc { Sidekiq::VERSION },
       proc { |me, data| data["tag"] },
-      proc { |me, data| "[#{Processor::WORK_STATE.size} of #{data["concurrency"]} busy]" },
+      proc { |me, data| "[#{Processor::WORK_STATE.size} of #{me.config.total_concurrency} busy]" },
       proc { |me, data| "stopping" if me.stopping? }
     ]
 
-    attr_accessor :manager, :poller, :fetcher
+    attr_accessor :managers, :poller
 
-    def initialize(options)
-      @config = options
-      options[:fetch] ||= BasicFetch.new(options)
-      @manager = Sidekiq::Manager.new(options)
-      @poller = Sidekiq::Scheduled::Poller.new(options)
+    def initialize(config, embedded: false)
+      @config = config
+      @embedded = embedded
+      @managers = config.capsules.values.map do |cap|
+        Sidekiq::Manager.new(cap)
+      end
+      @poller = Sidekiq::Scheduled::Poller.new(@config)
       @done = false
     end
 
-    def run
-      @thread = safe_thread("heartbeat", &method(:start_heartbeat))
+    # Start this Sidekiq instance. If an embedding process already
+    # 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)
+      logger.debug { @config.merge!({}) }
+      Sidekiq.freeze!
+      @thread = safe_thread("heartbeat", &method(:start_heartbeat)) if async_beat
       @poller.start
-      @manager.start
+      @managers.each(&:start)
     end
 
     # Stops this instance from processing any more jobs,
-    #
     def quiet
+      return if @done
+
       @done = true
-      @manager.quiet
+      @managers.each(&:quiet)
       @poller.terminate
+      fire_event(:quiet, reverse: true)
     end
 
     # Shuts down this Sidekiq instance. Waits up to the deadline for all jobs to complete.
     def stop
       deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + @config[:timeout]
 
-      @done = true
-      @manager.quiet
-      @poller.terminate
-
-      @manager.stop(deadline)
+      quiet
+      stoppers = @managers.map do |mgr|
+        Thread.new do
+          mgr.stop(deadline)
+        end
+      end
 
-      # 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 = @config[:fetch]
-      strategy.bulk_requeue([], @config)
+      fire_event(:shutdown, reverse: true)
+      stoppers.each(&:join)
 
       clear_heartbeat
     end
@@ -66,18 +74,30 @@ module Sidekiq
       @done
     end
 
+    # If embedding Sidekiq, you can have the process heartbeat
+    # call this method to regularly heartbeat rather than creating
+    # a separate thread.
+    def heartbeat
+      ❤
+    end
+
     private unless $TESTING
 
-    BEAT_PAUSE = 5
+    BEAT_PAUSE = 10
 
     def start_heartbeat
       loop do
-        heartbeat
+        beat
         sleep BEAT_PAUSE
       end
       logger.info("Heartbeat stopping...")
     end
 
+    def beat
+      $0 = PROCTITLES.map { |proc| proc.call(self, to_data) }.compact.join(" ") unless @embedded
+      ❤
+    end
+
     def clear_heartbeat
       flush_stats
 
@@ -94,12 +114,6 @@ module Sidekiq
       # best effort, ignore network errors
     end
 
-    def heartbeat
-      $0 = PROCTITLES.map { |proc| proc.call(self, to_data) }.compact.join(" ")
-
-      ❤
-    end
-
     def flush_stats
       fails = Processor::FAILURE.reset
       procd = Processor::PROCESSED.reset
@@ -107,7 +121,7 @@ module Sidekiq
 
       nowdate = Time.now.utc.strftime("%Y-%m-%d")
       begin
-        Sidekiq.redis do |conn|
+        redis do |conn|
           conn.pipelined do |pipeline|
             pipeline.incrby("stat:processed", procd)
             pipeline.incrby("stat:processed:#{nowdate}", procd)
@@ -119,9 +133,7 @@ module Sidekiq
           end
         end
       rescue => ex
-        # we're exiting the process, things might be shut down so don't
-        # try to handle the exception
-        Sidekiq.logger.warn("Unable to flush stats: #{ex}")
+        logger.warn("Unable to flush stats: #{ex}")
       end
     end
 
@@ -130,31 +142,20 @@ module Sidekiq
       fails = procd = 0
 
       begin
-        fails = Processor::FAILURE.reset
-        procd = Processor::PROCESSED.reset
-        curstate = Processor::WORK_STATE.dup
+        flush_stats
 
-        nowdate = Time.now.utc.strftime("%Y-%m-%d")
+        curstate = Processor::WORK_STATE.dup
+        curstate.transform_values! { |val| Sidekiq.dump_json(val) }
 
         redis do |conn|
-          conn.multi do |transaction|
-            transaction.incrby("stat:processed", procd)
-            transaction.incrby("stat:processed:#{nowdate}", procd)
-            transaction.expire("stat:processed:#{nowdate}", STATS_TTL)
-
-            transaction.incrby("stat:failed", fails)
-            transaction.incrby("stat:failed:#{nowdate}", fails)
-            transaction.expire("stat:failed:#{nowdate}", STATS_TTL)
-          end
-
           # 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
 
@@ -163,11 +164,11 @@ module Sidekiq
         fails = procd = 0
         kb = memory_usage(::Process.pid)
 
-        _, exists, _, _, msg = redis { |conn|
+        _, exists, _, _, signal = redis { |conn|
           conn.multi { |transaction|
             transaction.sadd("processes", [key])
-            transaction.exists?(key)
-            transaction.hmset(key, "info", to_json,
+            transaction.exists(key)
+            transaction.hset(key, "info", to_json,
               "busy", curstate.size,
               "beat", Time.now.to_f,
               "rtt_us", rtt,
@@ -179,12 +180,10 @@ module Sidekiq
         }
 
         # first heartbeat or recovering from an outage and need to reestablish our heartbeat
-        fire_event(:heartbeat) unless exists
+        fire_event(:heartbeat) unless exists > 0
         fire_event(:beat, oneshot: false)
 
-        return unless msg
-
-        ::Process.kill(msg, ::Process.pid)
+        ::Process.kill(signal, ::Process.pid) if signal && !@embedded
       rescue => e
         # ignore all redis/network issues
         logger.error("heartbeat: #{e}")
@@ -218,7 +217,7 @@ module Sidekiq
           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.
           If these values are close to 100,000, that means your Sidekiq process may be
-          CPU-saturated; reduce your concurrency and/or see https://github.com/mperham/sidekiq/discussions/5039
+          CPU-saturated; reduce your concurrency and/or see https://github.com/sidekiq/sidekiq/discussions/5039
         EOM
         RTT_READINGS.reset
       end
@@ -251,13 +250,20 @@ module Sidekiq
         "started_at" => Time.now.to_f,
         "pid" => ::Process.pid,
         "tag" => @config[:tag] || "",
-        "concurrency" => @config[:concurrency],
-        "queues" => @config[:queues].uniq,
-        "labels" => @config[:labels],
-        "identity" => identity
+        "concurrency" => @config.total_concurrency,
+        "queues" => @config.capsules.values.flat_map { |cap| cap.queues }.uniq,
+        "weights" => to_weights,
+        "labels" => @config[:labels].to_a,
+        "identity" => identity,
+        "version" => Sidekiq::VERSION,
+        "embedded" => @embedded
       }
     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/logger.rb

@@ -31,12 +31,12 @@ module Sidekiq
       "fatal" => 4
     }
     LEVELS.default_proc = proc do |_, level|
-      Sidekiq.logger.warn("Invalid log level: #{level.inspect}")
+      puts("Invalid log level: #{level.inspect}")
       nil
     end
 
     LEVELS.each do |level, numeric_level|
-      define_method("#{level}?") do
+      define_method(:"#{level}?") do
         local_level.nil? ? super() : local_level <= numeric_level
       end
     end
@@ -70,36 +70,11 @@ module Sidekiq
     ensure
       self.local_level = old_local_level
     end
-
-    # Redefined to check severity against #level, and thus the thread-local level, rather than +@level+.
-    # FIXME: Remove when the minimum Ruby version supports overriding Logger#level.
-    def add(severity, message = nil, progname = nil, &block)
-      severity ||= ::Logger::UNKNOWN
-      progname ||= @progname
-
-      return true if @logdev.nil? || severity < level
-
-      if message.nil?
-        if block
-          message = yield
-        else
-          message = progname
-          progname = @progname
-        end
-      end
-
-      @logdev.write format_message(format_severity(severity), Time.now, progname, message)
-    end
   end
 
   class Logger < ::Logger
     include LoggingUtils
 
-    def initialize(*args, **kwargs)
-      super
-      self.formatter = Sidekiq.log_formatter
-    end
-
     module Formatters
       class Base < ::Logger::Formatter
         def tid

data/lib/sidekiq/manager.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "sidekiq/processor"
-require "sidekiq/fetch"
 require "set"
 
 module Sidekiq
@@ -23,19 +22,19 @@ module Sidekiq
     include Sidekiq::Component
 
     attr_reader :workers
+    attr_reader :capsule
 
-    def initialize(options = {})
-      @config = options
-      logger.debug { options.inspect }
-      @count = options[:concurrency] || 10
+    def initialize(capsule)
+      @config = @capsule = capsule
+      @count = capsule.concurrency
       raise ArgumentError, "Concurrency of #{@count} is not supported" if @count < 1
 
       @done = false
       @workers = Set.new
+      @plock = Mutex.new
       @count.times do
         @workers << Processor.new(@config, &method(:processor_result))
       end
-      @plock = Mutex.new
     end
 
     def start
@@ -46,14 +45,12 @@ module Sidekiq
       return if @done
       @done = true
 
-      logger.info { "Terminating quiet threads" }
+      logger.info { "Terminating quiet threads for #{capsule.name} capsule" }
       @workers.each(&:terminate)
-      fire_event(:quiet, reverse: true)
     end
 
     def stop(deadline)
       quiet
-      fire_event(:shutdown, reverse: true)
 
       # some of the shutdown events can be async,
       # we don't have any way to know when they're done but
@@ -66,6 +63,8 @@ module Sidekiq
       return if @workers.empty?
 
       hard_shutdown
+    ensure
+      capsule.stop
     end
 
     def processor_result(processor, reason = nil)
@@ -105,8 +104,7 @@ 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 = @config[:fetch]
-        strategy.bulk_requeue(jobs, @config)
+        capsule.fetcher.bulk_requeue(jobs)
       end
 
       cleanup.each do |processor|

data/lib/sidekiq/metrics/query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sidekiq"
 require "date"
 require "set"
@@ -13,14 +15,15 @@ module Sidekiq
     # 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)
+      def initialize(pool: nil, now: Time.now)
         @time = now.utc
-        @pool = pool
+        @pool = pool || Sidekiq.default_configuration.redis_pool
         @klass = nil
       end
 
       # Get metric data for all jobs from the last hour
-      def top_jobs(minutes: 60)
+      #  +class_filter+: return only results for classes matching filter
+      def top_jobs(class_filter: nil, minutes: 60)
         result = Result.new
 
         time = @time
@@ -39,6 +42,7 @@ module Sidekiq
         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
@@ -70,7 +74,7 @@ module Sidekiq
             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)
+            result.job_results[klass].add_hist time, Histogram.new(klass).fetch(conn, time).reverse
             time -= 60
           end
         end
@@ -117,6 +121,7 @@ module Sidekiq
 
         def total_avg(metric = "ms")
           completed = totals["p"] - totals["f"]
+          return 0 if completed.zero?
           totals[metric].to_f / completed
         end
 

data/lib/sidekiq/metrics/shared.rb

@@ -1,9 +1,21 @@
-require "concurrent"
+# frozen_string_literal: true
 
 module Sidekiq
   module Metrics
-    # TODO Support apps without concurrent-ruby
-    Counter = ::Concurrent::AtomicFixnum
+    class Counter
+      def initialize
+        @value = 0
+        @lock = Mutex.new
+      end
+
+      def increment
+        @lock.synchronize { @value += 1 }
+      end
+
+      def value
+        @lock.synchronize { @value }
+      end
+    end
 
     # Implements space-efficient but statistically useful histogram storage.
     # A precise time histogram stores every time. Instead we break times into a set of
@@ -28,8 +40,8 @@ module Sidekiq
         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
-      ]
+        1e20 # the "maybe your job is too long" bucket
+      ].freeze
       LABELS = [
         "20ms", "30ms", "45ms", "65ms", "100ms",
         "150ms", "225ms", "335ms", "500ms", "750ms",
@@ -37,8 +49,7 @@ module Sidekiq
         "8.5s", "13s", "20s", "30s", "45s",
         "65s", "100s", "150s", "225s", "335s",
         "Slow"
-      ]
-
+      ].freeze
       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 \
@@ -46,6 +57,7 @@ module Sidekiq
         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
+      HISTOGRAM_TTL = 8 * 60 * 60
 
       def each
         buckets.each { |counter| yield counter.value }
@@ -72,7 +84,7 @@ module Sidekiq
       def fetch(conn, now = Time.now)
         window = now.utc.strftime("%d-%H:%-M")
         key = "#{@klass}-#{window}"
-        conn.bitfield(key, *FETCH)
+        conn.bitfield_ro(key, *FETCH)
       end
 
       def persist(conn, now = Time.now)
@@ -86,7 +98,7 @@ module Sidekiq
         end
 
         conn.bitfield(*cmd) if cmd.size > 3
-        conn.expire(key, 86400)
+        conn.expire(key, HISTOGRAM_TTL)
         key
       end
     end

data/lib/sidekiq/metrics/tracking.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "time"
 require "sidekiq"
 require "sidekiq/metrics/shared"
@@ -29,11 +31,11 @@ module Sidekiq
           # 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
-          }
+          track_time(klass, time_ms)
+        rescue JobRetry::Skip
+          # This is raised when iterable job is interrupted.
+          track_time(klass, time_ms)
+          raise
         rescue Exception
           @lock.synchronize {
             @jobs["#{klass}|f"] += 1
@@ -48,8 +50,8 @@ module Sidekiq
         end
       end
 
-      LONG_TERM = 90 * 24 * 60 * 60
-      MID_TERM = 7 * 24 * 60 * 60
+      # LONG_TERM = 90 * 24 * 60 * 60
+      # MID_TERM = 7 * 24 * 60 * 60
       SHORT_TERM = 8 * 60 * 60
 
       def flush(time = Time.now)
@@ -59,12 +61,13 @@ module Sidekiq
         return if procd == 0 && fails == 0
 
         now = time.utc
-        nowdate = now.strftime("%Y%m%d")
-        nowhour = now.strftime("%Y%m%d|%-H")
+        # 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|
+          # persist fine-grained histogram data
           if grams.size > 0
             conn.pipelined do |pipe|
               grams.each do |_, gram|
@@ -73,15 +76,16 @@ module Sidekiq
             end
           end
 
+          # persist coarse grained execution count + execution millis.
+          # note as of today we don't use or do anything with the
+          # daily or hourly rollups.
           [
-            ["j", jobs, nowdate, LONG_TERM],
-            ["j", jobs, nowhour, MID_TERM],
+            # ["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
@@ -89,22 +93,34 @@ module Sidekiq
               xa.expire(stats, ttl)
             end
           end
-          logger.info "Flushed #{count} metrics"
+          logger.debug "Flushed #{count} metrics"
           count
         end
       end
 
       private
 
+      def track_time(klass, time_ms)
+        @lock.synchronize {
+          @grams[klass].record_time(time_ms)
+          @jobs["#{klass}|ms"] += time_ms
+          @totals["ms"] += time_ms
+        }
+      end
+
       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) }
+          reset_instance_variables
           array
         }
       end
+
+      def reset_instance_variables
+        @totals = Hash.new(0)
+        @jobs = Hash.new(0)
+        @grams = Hash.new { |hash, key| hash[key] = Histogram.new(key) }
+      end
     end
 
     class Middleware
@@ -121,14 +137,12 @@ module Sidekiq
   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
+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