sidekiq 3.5.4 → 7.2.0

data/lib/sidekiq/manager.rb

@@ -1,236 +1,134 @@
-# encoding: utf-8
-require 'sidekiq/util'
-require 'sidekiq/actor'
-require 'sidekiq/processor'
-require 'sidekiq/fetch'
+# frozen_string_literal: true
 
-module Sidekiq
+require "sidekiq/processor"
+require "set"
 
+module Sidekiq
   ##
-  # The main router in the system.  This
-  # manages the processor state and accepts messages
-  # from Redis to be dispatched to an idle processor.
+  # The Manager is the central coordination point in Sidekiq, controlling
+  # the lifecycle of the Processors.
+  #
+  # Tasks:
+  #
+  # 1. start: Spin up Processors.
+  # 3. processor_died: Handle job failure, throw away Processor, create new one.
+  # 4. quiet: shutdown idle Processors.
+  # 5. stop: hard stop the Processors by deadline.
+  #
+  # Note that only the last task requires its own Thread since it has to monitor
+  # the shutdown process.  The other tasks are performed by other threads.
   #
   class Manager
-    include Util
-    include Actor
-    trap_exit :processor_died
+    include Sidekiq::Component
 
-    attr_reader :ready
-    attr_reader :busy
-    attr_accessor :fetcher
+    attr_reader :workers
+    attr_reader :capsule
 
-    SPIN_TIME_FOR_GRACEFUL_SHUTDOWN = 1
-    JVM_RESERVED_SIGNALS = ['USR1', 'USR2'] # Don't Process#kill if we get these signals via the API
-
-    def initialize(condvar, options={})
-      logger.debug { options.inspect }
-      @options = options
-      @count = options[:concurrency] || 25
+    def initialize(capsule)
+      @config = @capsule = capsule
+      @count = capsule.concurrency
       raise ArgumentError, "Concurrency of #{@count} is not supported" if @count < 1
-      @done_callback = nil
-      @finished = condvar
 
-      @in_progress = {}
-      @threads = {}
       @done = false
-      @busy = []
-      @ready = @count.times.map do
-        p = Processor.new_link(current_actor)
-        p.proxy_id = p.object_id
-        p
+      @workers = Set.new
+      @plock = Mutex.new
+      @count.times do
+        @workers << Processor.new(@config, &method(:processor_result))
       end
     end
 
-    def stop(options={})
-      watchdog('Manager#stop died') do
-        should_shutdown = options[:shutdown]
-        timeout = options[:timeout]
-
-        @done = true
-
-        logger.info { "Terminating #{@ready.size} quiet workers" }
-        @ready.each { |x| x.terminate if x.alive? }
-        @ready.clear
-
-        return if clean_up_for_graceful_shutdown
-
-        hard_shutdown_in timeout if should_shutdown
-      end
+    def start
+      @workers.each(&:start)
     end
 
-    def clean_up_for_graceful_shutdown
-      if @busy.empty?
-        shutdown
-        return true
-      end
+    def quiet
+      return if @done
+      @done = true
 
-      after(SPIN_TIME_FOR_GRACEFUL_SHUTDOWN) { clean_up_for_graceful_shutdown }
-      false
+      logger.info { "Terminating quiet threads for #{capsule.name} capsule" }
+      @workers.each(&:terminate)
     end
 
-    def start
-      @ready.each { dispatch }
-    end
+    def stop(deadline)
+      quiet
 
-    def when_done(&blk)
-      @done_callback = blk
-    end
+      # some of the shutdown events can be async,
+      # we don't have any way to know when they're done but
+      # give them a little time to take effect
+      sleep PAUSE_TIME
+      return if @workers.empty?
 
-    def processor_done(processor)
-      watchdog('Manager#processor_done died') do
-        @done_callback.call(processor) if @done_callback
-        @in_progress.delete(processor.object_id)
-        @threads.delete(processor.object_id)
-        @busy.delete(processor)
-        if stopped?
-          processor.terminate if processor.alive?
-          shutdown if @busy.empty?
-        else
-          @ready << processor if processor.alive?
-        end
-        dispatch
-      end
-    end
+      logger.info { "Pausing to allow jobs to finish..." }
+      wait_for(deadline) { @workers.empty? }
+      return if @workers.empty?
 
-    def processor_died(processor, reason)
-      watchdog("Manager#processor_died died") do
-        @in_progress.delete(processor.object_id)
-        @threads.delete(processor.object_id)
-        @busy.delete(processor)
-
-        unless stopped?
-          p = Processor.new_link(current_actor)
-          p.proxy_id = p.object_id
-          @ready << p
-          dispatch
-        else
-          shutdown if @busy.empty?
-        end
-      end
+      hard_shutdown
+    ensure
+      capsule.stop
     end
 
-    def assign(work)
-      watchdog("Manager#assign died") do
-        if stopped?
-          # Race condition between Manager#stop if Fetcher
-          # is blocked on redis and gets a message after
-          # all the ready Processors have been stopped.
-          # Push the message back to redis.
-          work.requeue
-        else
-          processor = @ready.pop
-          @in_progress[processor.object_id] = work
-          @busy << processor
-          processor.async.process(work)
+    def processor_result(processor, reason = nil)
+      @plock.synchronize do
+        @workers.delete(processor)
+        unless @done
+          p = Processor.new(@config, &method(:processor_result))
+          @workers << p
+          p.start
         end
       end
     end
 
-    # A hack worthy of Rube Goldberg.  We need to be able
-    # to hard stop a working thread.  But there's no way for us to
-    # get handle to the underlying thread performing work for a processor
-    # so we have it call us and tell us.
-    def real_thread(proxy_id, thr)
-      @threads[proxy_id] = thr if thr.alive?
-    end
-
-    PROCTITLES = [
-      proc { 'sidekiq'.freeze },
-      proc { Sidekiq::VERSION },
-      proc { |mgr, data| data['tag'] },
-      proc { |mgr, data| "[#{mgr.busy.size} of #{data['concurrency']} busy]" },
-      proc { |mgr, data| "stopping" if mgr.stopped? },
-    ]
-
-    def heartbeat(key, data, json)
-      results = PROCTITLES.map {|x| x.(self, data) }
-      results.compact!
-      $0 = results.join(' ')
-
-      ❤(key, json)
-      after(5) do
-        heartbeat(key, data, json)
-      end
-    end
-
     def stopped?
       @done
     end
 
     private
 
-    def ❤(key, json)
-      begin
-        _, _, _, msg = Sidekiq.redis do |conn|
-          conn.multi do
-            conn.sadd('processes', key)
-            conn.hmset(key, 'info', json, 'busy', @busy.size, 'beat', Time.now.to_f)
-            conn.expire(key, 60)
-            conn.rpop("#{key}-signals")
-          end
-        end
-
-        return unless msg
-
-        if JVM_RESERVED_SIGNALS.include?(msg)
-          Sidekiq::CLI.instance.handle_signal(msg)
-        else
-          ::Process.kill(msg, $$)
-        end
-      rescue => e
-        # ignore all redis/network issues
-        logger.error("heartbeat: #{e.message}")
+    def hard_shutdown
+      # We've reached the timeout and we still have busy threads.
+      # They must die but their jobs shall live on.
+      cleanup = nil
+      @plock.synchronize do
+        cleanup = @workers.dup
       end
-    end
-
-    def hard_shutdown_in(delay)
-      logger.info { "Pausing up to #{delay} seconds to allow workers to finish..." }
 
-      after(delay) do
-        watchdog("Manager#hard_shutdown_in died") do
-          # We've reached the timeout and we still have busy workers.
-          # They must die but their messages shall live on.
-          logger.warn { "Terminating #{@busy.size} busy worker threads" }
-          logger.warn { "Work still in progress #{@in_progress.values.inspect}" }
+      if cleanup.size > 0
+        jobs = cleanup.map { |p| p.job }.compact
 
-          requeue
+        logger.warn { "Terminating #{cleanup.size} busy threads" }
+        logger.debug { "Jobs still in progress #{jobs.inspect}" }
 
-          @busy.each do |processor|
-            if processor.alive? && t = @threads.delete(processor.object_id)
-              t.raise Shutdown
-            end
-          end
-
-          @finished.signal
-        end
+        # Re-enqueue unfinished jobs
+        # NOTE: You may notice that we may push a job back to redis before
+        # the thread is terminated. This is ok because Sidekiq's
+        # 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.
+        capsule.fetcher.bulk_requeue(jobs)
       end
-    end
 
-    def dispatch
-      return if stopped?
-      # This is a safety check to ensure we haven't leaked
-      # processors somehow.
-      raise "BUG: No processors, cannot continue!" if @ready.empty? && @busy.empty?
-      raise "No ready processor!?" if @ready.empty?
+      cleanup.each do |processor|
+        processor.kill
+      end
 
-      @fetcher.async.fetch
+      # when this method returns, we immediately call `exit` which may not give
+      # the remaining threads time to run `ensure` blocks, etc. We pause here up
+      # to 3 seconds to give threads a minimal amount of time to run `ensure` blocks.
+      deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + 3
+      wait_for(deadline) { @workers.empty? }
     end
 
-    def shutdown
-      requeue
-      @finished.signal
-    end
+    # hack for quicker development / testing environment #2774
+    PAUSE_TIME = $stdout.tty? ? 0.1 : 0.5
 
-    def requeue
-      # Re-enqueue terminated jobs
-      # NOTE: You may notice that we may push a job back to redis before
-      # the worker thread is terminated. This is ok because Sidekiq's
-      # 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.
-      Sidekiq::Fetcher.strategy.bulk_requeue(@in_progress.values, @options)
-      @in_progress.clear
+    # 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/query.rb

@@ -0,0 +1,155 @@
+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: nil, now: Time.now)
+        @time = now.utc
+        @pool = pool || Sidekiq.default_configuration.redis_pool
+        @klass = nil
+      end
+
+      # 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
+
+        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("|")
+            next if class_filter && !class_filter.match?(kls)
+            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).reverse
+            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,95 @@
+require "concurrent"
+
+module Sidekiq
+  module Metrics
+    # This is the only dependency on concurrent-ruby in Sidekiq but it's
+    # mandatory for thread-safety until MRI supports atomic operations on values.
+    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,
+        1e20 # the "maybe your job is too long" bucket
+      ].freeze
+      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"
+      ].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 \
+        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
+      HISTOGRAM_TTL = 8 * 60 * 60
+
+      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_ro(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, HISTOGRAM_TTL)
+        key
+      end
+    end
+  end
+end