sidekiq 6.0.0

data/lib/sidekiq/launcher.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "sidekiq/manager"
+require "sidekiq/fetch"
+require "sidekiq/scheduled"
+
+module Sidekiq
+  # The Launcher starts the Manager and Poller threads and provides the process heartbeat.
+  class Launcher
+    include Util
+
+    STATS_TTL = 5 * 365 * 24 * 60 * 60 # 5 years
+
+    PROCTITLES = [
+      proc { "sidekiq" },
+      proc { Sidekiq::VERSION },
+      proc { |me, data| data["tag"] },
+      proc { |me, data| "[#{Processor::WORKER_STATE.size} of #{data["concurrency"]} busy]" },
+      proc { |me, data| "stopping" if me.stopping? },
+    ]
+
+    attr_accessor :manager, :poller, :fetcher
+
+    def initialize(options)
+      @manager = Sidekiq::Manager.new(options)
+      @poller = Sidekiq::Scheduled::Poller.new
+      @done = false
+      @options = options
+    end
+
+    def run
+      @thread = safe_thread("heartbeat", &method(:start_heartbeat))
+      @poller.start
+      @manager.start
+    end
+
+    # Stops this instance from processing any more jobs,
+    #
+    def quiet
+      @done = true
+      @manager.quiet
+      @poller.terminate
+    end
+
+    # Shuts down the process.  This method does not
+    # return until all work is complete and cleaned up.
+    # It can take up to the timeout to complete.
+    def stop
+      deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + @options[:timeout]
+
+      @done = true
+      @manager.quiet
+      @poller.terminate
+
+      @manager.stop(deadline)
+
+      # Requeue everything in case there was a worker who grabbed work while stopped
+      # This call is a no-op in Sidekiq but necessary for Sidekiq Pro.
+      strategy = (@options[:fetch] || Sidekiq::BasicFetch)
+      strategy.bulk_requeue([], @options)
+
+      clear_heartbeat
+    end
+
+    def stopping?
+      @done
+    end
+
+    private unless $TESTING
+
+    def start_heartbeat
+      loop do
+        heartbeat
+        sleep 5
+      end
+      Sidekiq.logger.info("Heartbeat stopping...")
+    end
+
+    def clear_heartbeat
+      # 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|
+        conn.pipelined do
+          conn.srem("processes", identity)
+          conn.del("#{identity}:workers")
+        end
+      end
+    rescue
+      # best effort, ignore network errors
+    end
+
+    def heartbeat
+      $0 = PROCTITLES.map { |proc| proc.call(self, to_data) }.compact.join(" ")
+
+      ❤
+    end
+
+    def ❤
+      key = identity
+      fails = procd = 0
+
+      begin
+        fails = Processor::FAILURE.reset
+        procd = Processor::PROCESSED.reset
+        curstate = Processor::WORKER_STATE.dup
+
+        workers_key = "#{key}:workers"
+        nowdate = Time.now.utc.strftime("%Y-%m-%d")
+
+        Sidekiq.redis do |conn|
+          conn.multi do
+            conn.incrby("stat:processed", procd)
+            conn.incrby("stat:processed:#{nowdate}", procd)
+            conn.expire("stat:processed:#{nowdate}", STATS_TTL)
+
+            conn.incrby("stat:failed", fails)
+            conn.incrby("stat:failed:#{nowdate}", fails)
+            conn.expire("stat:failed:#{nowdate}", STATS_TTL)
+
+            conn.del(workers_key)
+            curstate.each_pair do |tid, hash|
+              conn.hset(workers_key, tid, Sidekiq.dump_json(hash))
+            end
+            conn.expire(workers_key, 60)
+          end
+        end
+
+        fails = procd = 0
+
+        _, exists, _, _, msg = Sidekiq.redis { |conn|
+          res = conn.multi {
+            conn.sadd("processes", key)
+            conn.exists(key)
+            conn.hmset(key, "info", to_json, "busy", curstate.size, "beat", Time.now.to_f, "quiet", @done)
+            conn.expire(key, 60)
+            conn.rpop("#{key}-signals")
+          }
+
+          res
+        }
+
+        # first heartbeat or recovering from an outage and need to reestablish our heartbeat
+        fire_event(:heartbeat) unless exists
+
+        return unless msg
+
+        ::Process.kill(msg, ::Process.pid)
+      rescue => e
+        # ignore all redis/network issues
+        logger.error("heartbeat: #{e.message}")
+        # don't lose the counts if there was a network issue
+        Processor::PROCESSED.incr(procd)
+        Processor::FAILURE.incr(fails)
+      end
+    end
+
+    def to_data
+      @data ||= begin
+        {
+          "hostname" => hostname,
+          "started_at" => Time.now.to_f,
+          "pid" => ::Process.pid,
+          "tag" => @options[:tag] || "",
+          "concurrency" => @options[:concurrency],
+          "queues" => @options[:queues].uniq,
+          "labels" => @options[:labels],
+          "identity" => identity,
+        }
+      end
+    end
+
+    def to_json
+      @json ||= begin
+        # this data changes infrequently so dump it to a string
+        # now so we don't need to dump it every heartbeat.
+        Sidekiq.dump_json(to_data)
+      end
+    end
+  end
+end

data/lib/sidekiq/logger.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "logger"
+require "time"
+
+module Sidekiq
+  class Logger < ::Logger
+    def initialize(*args)
+      super
+
+      self.formatter = Sidekiq.log_formatter
+    end
+
+    def with_context(hash)
+      ctx.merge!(hash)
+      yield
+    ensure
+      hash.keys.each { |key| ctx.delete(key) }
+    end
+
+    def ctx
+      Thread.current[:sidekiq_context] ||= {}
+    end
+
+    module Formatters
+      class Base < ::Logger::Formatter
+        def tid
+          Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
+        end
+
+        def ctx
+          Thread.current[:sidekiq_context] ||= {}
+        end
+
+        def format_context
+          " " + ctx.compact.map { |k, v| "#{k}=#{v}" }.join(" ") if ctx.any?
+        end
+      end
+
+      class Pretty < Base
+        def call(severity, time, program_name, message)
+          "#{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context} #{severity}: #{message}\n"
+        end
+      end
+
+      class WithoutTimestamp < Pretty
+        def call(severity, time, program_name, message)
+          "pid=#{::Process.pid} tid=#{tid}#{format_context} #{severity}: #{message}\n"
+        end
+      end
+
+      class JSON < Base
+        def call(severity, time, program_name, message)
+          hash = {
+            ts: time.utc.iso8601(3),
+            pid: ::Process.pid,
+            tid: tid,
+            lvl: severity,
+            msg: message,
+          }
+          c = ctx
+          hash["ctx"] = c unless c.empty?
+
+          Sidekiq.dump_json(hash) << "\n"
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/manager.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "sidekiq/util"
+require "sidekiq/processor"
+require "sidekiq/fetch"
+require "set"
+
+module Sidekiq
+  ##
+  # 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
+
+    attr_reader :workers
+    attr_reader :options
+
+    def initialize(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)
+      end
+      @plock = Mutex.new
+    end
+
+    def start
+      @workers.each do |x|
+        x.start
+      end
+    end
+
+    def quiet
+      return if @done
+      @done = true
+
+      logger.info { "Terminating quiet workers" }
+      @workers.each { |x| x.terminate }
+      fire_event(:quiet, reverse: true)
+    end
+
+    # hack for quicker development / testing environment #2774
+    PAUSE_TIME = STDOUT.tty? ? 0.1 : 0.5
+
+    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
+      # give them a little time to take effect
+      sleep PAUSE_TIME
+      return if @workers.empty?
+
+      logger.info { "Pausing to allow workers to finish..." }
+      remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      while remaining > PAUSE_TIME
+        return if @workers.empty?
+        sleep PAUSE_TIME
+        remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+      return if @workers.empty?
+
+      hard_shutdown
+    end
+
+    def processor_stopped(processor)
+      @plock.synchronize do
+        @workers.delete(processor)
+      end
+    end
+
+    def processor_died(processor, reason)
+      @plock.synchronize do
+        @workers.delete(processor)
+        unless @done
+          p = Processor.new(self)
+          @workers << p
+          p.start
+        end
+      end
+    end
+
+    def stopped?
+      @done
+    end
+
+    private
+
+    def hard_shutdown
+      # We've reached the timeout and we still have busy workers.
+      # They must die but their jobs shall live on.
+      cleanup = nil
+      @plock.synchronize do
+        cleanup = @workers.dup
+      end
+
+      if cleanup.size > 0
+        jobs = cleanup.map { |p| p.job }.compact
+
+        logger.warn { "Terminating #{cleanup.size} busy worker threads" }
+        logger.warn { "Work still in progress #{jobs.inspect}" }
+
+        # Re-enqueue unfinished 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.
+        strategy = (@options[:fetch] || Sidekiq::BasicFetch)
+        strategy.bulk_requeue(jobs, @options)
+      end
+
+      cleanup.each do |processor|
+        processor.kill
+      end
+    end
+  end
+end

data/lib/sidekiq/middleware/chain.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  # Middleware is code configured to run before/after
+  # a message 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).
+  #
+  # To add middleware for the client:
+  #
+  # Sidekiq.configure_client do |config|
+  #   config.client_middleware do |chain|
+  #     chain.add MyClientHook
+  #   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
+  #   end
+  # end
+  #
+  # To insert immediately preceding another entry:
+  #
+  # Sidekiq.configure_client do |config|
+  #   config.client_middleware do |chain|
+  #     chain.insert_before ActiveRecord, MyClientHook
+  #   end
+  # end
+  #
+  # To insert immediately after another entry:
+  #
+  # Sidekiq.configure_client do |config|
+  #   config.client_middleware do |chain|
+  #     chain.insert_after ActiveRecord, MyClientHook
+  #   end
+  # end
+  #
+  # This is an example of a minimal server middleware:
+  #
+  # class MyServerHook
+  #   def call(worker_instance, msg, queue)
+  #     puts "Before work"
+  #     yield
+  #     puts "After work"
+  #   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
+  #   def call(worker_class, msg, queue, redis_pool)
+  #     puts "Before push"
+  #     result = yield
+  #     puts "After push"
+  #     result
+  #   end
+  # end
+  #
+  module Middleware
+    class Chain
+      include Enumerable
+      attr_reader :entries
+
+      def initialize_copy(copy)
+        copy.instance_variable_set(:@entries, entries.dup)
+      end
+
+      def each(&block)
+        entries.each(&block)
+      end
+
+      def initialize
+        @entries = []
+        yield self if block_given?
+      end
+
+      def remove(klass)
+        entries.delete_if { |entry| entry.klass == klass }
+      end
+
+      def add(klass, *args)
+        remove(klass) if exists?(klass)
+        entries << Entry.new(klass, *args)
+      end
+
+      def prepend(klass, *args)
+        remove(klass) if exists?(klass)
+        entries.insert(0, Entry.new(klass, *args))
+      end
+
+      def insert_before(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || 0
+        entries.insert(i, new_entry)
+      end
+
+      def insert_after(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
+        entries.insert(i + 1, new_entry)
+      end
+
+      def exists?(klass)
+        any? { |entry| entry.klass == klass }
+      end
+
+      def retrieve
+        map(&:make_new)
+      end
+
+      def clear
+        entries.clear
+      end
+
+      def invoke(*args)
+        chain = retrieve.dup
+        traverse_chain = lambda do
+          if chain.empty?
+            yield
+          else
+            chain.shift.call(*args, &traverse_chain)
+          end
+        end
+        traverse_chain.call
+      end
+    end
+
+    class Entry
+      attr_reader :klass
+
+      def initialize(klass, *args)
+        @klass = klass
+        @args = args
+      end
+
+      def make_new
+        @klass.new(*@args)
+      end
+    end
+  end
+end