mini-clean-lib 0.0.1

data/sidekiq-8.1.6/lib/sidekiq/launcher.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require "sidekiq/manager"
+require "sidekiq/capsule"
+require "sidekiq/scheduled"
+require "sidekiq/ring_buffer"
+
+module Sidekiq
+  # The Launcher starts the Capsule Managers, the Poller thread and provides the process heartbeat.
+  class Launcher
+    include Sidekiq::Component
+
+    STATS_TTL = 5 * 365 * 24 * 60 * 60 # 5 years
+
+    PROCTITLES = [
+      proc { "sidekiq" },
+      proc { Sidekiq::VERSION },
+      proc { |me, data| data["tag"] },
+      proc { |me, data| "[#{Processor::WORK_STATE.size} of #{me.config.total_concurrency} busy]" },
+      proc { |me, data| "stopping" if me.stopping? }
+    ]
+
+    attr_accessor :managers, :poller
+
+    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
+
+    # 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
+      @managers.each(&:start)
+    end
+
+    # Stops this instance from processing any more jobs,
+    def quiet
+      return if @done
+
+      @done = true
+      @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]
+
+      quiet
+      stoppers = @managers.map do |mgr|
+        Thread.new do
+          mgr.stop(deadline)
+        end
+      end
+
+      fire_event(:shutdown, reverse: true)
+      stoppers.each(&:join)
+
+      clear_heartbeat
+      fire_event(:exit, reverse: true)
+    end
+
+    def stopping?
+      @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
+
+    BEAT_PAUSE = 10
+
+    def start_heartbeat
+      loop do
+        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
+
+      # 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.
+      redis do |conn|
+        conn.pipelined do |pipeline|
+          pipeline.srem("processes", [identity])
+          pipeline.unlink("#{identity}:work")
+        end
+      end
+    rescue
+      # best effort, ignore network errors
+    end
+
+    def flush_stats
+      fails = Processor::FAILURE.reset
+      procd = Processor::PROCESSED.reset
+      return if fails + procd == 0
+
+      nowdate = Time.now.utc.strftime("%Y-%m-%d")
+      begin
+        redis do |conn|
+          conn.pipelined do |pipeline|
+            pipeline.incrby("stat:processed", procd)
+            pipeline.incrby("stat:processed:#{nowdate}", procd)
+            pipeline.expire("stat:processed:#{nowdate}", STATS_TTL)
+
+            pipeline.incrby("stat:failed", fails)
+            pipeline.incrby("stat:failed:#{nowdate}", fails)
+            pipeline.expire("stat:failed:#{nowdate}", STATS_TTL)
+          end
+        end
+      rescue => ex
+        logger.warn("Unable to flush stats: #{ex}")
+      end
+    end
+
+    def ❤
+      key = identity
+      fails = procd = 0
+
+      idle_timeout = config[:redis_idle_timeout]
+      if idle_timeout
+        config.capsules.each_value { |cap| cap.local_redis_pool.reap(idle_seconds: idle_timeout, &:close) }
+        config.local_redis_pool.reap(idle_seconds: idle_timeout, &:close)
+      end
+
+      begin
+        flush_stats
+
+        curstate = Processor::WORK_STATE.dup
+        curstate.transform_values! { |val| Sidekiq.dump_json(val) }
+
+        redis do |conn|
+          # work is the current set of executing jobs
+          work_key = "#{key}:work"
+          conn.multi do |transaction|
+            transaction.unlink(work_key)
+            if curstate.size > 0
+              transaction.hset(work_key, curstate)
+              transaction.expire(work_key, 60)
+            end
+          end
+        end
+
+        rtt = check_rtt
+
+        fails = procd = 0
+        kb = memory_usage(::Process.pid)
+
+        _, exists, _, _, signal = redis { |conn|
+          conn.multi { |transaction|
+            transaction.sadd("processes", [key])
+            transaction.exists(key)
+            transaction.hset(key, "info", to_json,
+              "concurrency", @config.total_concurrency,
+              "busy", curstate.size,
+              "beat", Time.now.to_f,
+              "rtt_us", rtt,
+              "quiet", @done.to_s,
+              "rss", kb)
+            transaction.expire(key, 60)
+            transaction.rpop("#{key}-signals")
+          }
+        }
+
+        # first heartbeat or recovering from an outage and need to reestablish our heartbeat
+        fire_event(:heartbeat) unless exists > 0
+        fire_event(:beat, oneshot: false)
+
+        ::Process.kill(signal, ::Process.pid) if signal && !@embedded
+      rescue => e
+        # ignore all redis/network issues
+        logger.error("heartbeat: #{e}")
+        # don't lose the counts if there was a network issue
+        Processor::PROCESSED.incr(procd)
+        Processor::FAILURE.incr(fails)
+      end
+    end
+
+    # We run the heartbeat every five seconds.
+    # Capture five samples of RTT, log a warning if each sample
+    # is above our warning threshold.
+    RTT_READINGS = RingBuffer.new(5)
+    RTT_WARNING_LEVEL = 50_000
+
+    def check_rtt
+      a = b = 0
+      redis do |x|
+        a = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+        x.ping
+        b = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+      end
+      rtt = b - a
+      RTT_READINGS << rtt
+      # Ideal RTT for Redis is < 1000µs
+      # Workable is < 10,000µs
+      # Log a warning if it's a disaster.
+      if RTT_READINGS.all? { |x| x > RTT_WARNING_LEVEL }
+        logger.warn <<~EOM
+          Your Redis network connection appears to be performing 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 and that
+          your Sidekiq process is not CPU-saturated; reduce your concurrency and/or
+          see https://github.com/sidekiq/sidekiq/discussions/5039
+        EOM
+        RTT_READINGS.reset
+      end
+      rtt
+    end
+
+    MEMORY_GRABBER = case RUBY_PLATFORM
+    when /linux/
+      ->(pid) {
+        IO.readlines("/proc/#{$$}/status").each do |line|
+          next unless line.start_with?("VmRSS:")
+          break line.split[1].to_i
+        end
+      }
+    when /darwin|bsd/
+      ->(pid) {
+        `ps -o pid,rss -p #{pid}`.lines.last.split.last.to_i
+      }
+    else
+      ->(pid) { 0 }
+    end
+
+    def memory_usage(pid)
+      MEMORY_GRABBER.call(pid)
+    end
+
+    def to_data
+      @data ||= {
+        "hostname" => hostname,
+        "started_at" => Time.now.to_f,
+        "pid" => ::Process.pid,
+        "tag" => @config[:tag] || "",
+        "capsules" => @config.capsules.each_with_object({}) { |(name, cap), memo|
+          memo[name] = cap.to_h
+        },
+        #####
+        # TODO deprecated, remove in 9.0
+        # This data is now found in the `capsules` element above
+        "queues" => @config.capsules.values.flat_map { |cap| cap.queues }.uniq,
+        "weights" => @config.capsules.values.map(&:weights),
+        #####
+        "labels" => @config[:labels].to_a,
+        "identity" => identity,
+        "version" => Sidekiq::VERSION,
+        "embedded" => @embedded
+      }
+    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.
+      @json ||= Sidekiq.dump_json(to_data)
+    end
+  end
+end

data/sidekiq-8.1.6/lib/sidekiq/loader.rb

@@ -0,0 +1,57 @@
+module Sidekiq
+  require "sidekiq/component"
+
+  class Loader
+    include Sidekiq::Component
+
+    def initialize(cfg = Sidekiq.default_configuration)
+      @config = cfg
+      @load_hooks = Hash.new { |h, k| h[k] = [] }
+      @loaded = Set.new
+      @lock = Mutex.new
+    end
+
+    # Declares a block that will be executed when a Sidekiq component is fully
+    # loaded. If the component has already loaded, the block is executed
+    # immediately.
+    #
+    #   Sidekiq.loader.on_load(:api) do
+    #     # extend the sidekiq API
+    #   end
+    #
+    def on_load(name, &block)
+      # we don't want to hold the lock while calling the block
+      to_run = nil
+
+      @lock.synchronize do
+        if @loaded.include?(name)
+          to_run = block
+        else
+          @load_hooks[name] << block
+        end
+      end
+
+      to_run&.call
+      nil
+    end
+
+    # Executes all blocks registered to +name+ via on_load.
+    #
+    #   Sidekiq.loader.run_load_hooks(:api)
+    #
+    # In the case of the above example, it will execute all hooks registered for +:api+.
+    #
+    def run_load_hooks(name)
+      hks = @lock.synchronize do
+        @loaded << name
+        @load_hooks.delete(name)
+      end
+
+      hks&.each do |blk|
+        blk.call
+      rescue => ex
+        handle_exception(ex, hook: name)
+      end
+    end
+  end
+end

data/sidekiq-8.1.6/lib/sidekiq/logger.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "logger"
+require "time"
+
+module Sidekiq
+  module Context
+    def self.with(hash)
+      orig_context = current.dup
+      current.merge!(hash)
+      yield
+    ensure
+      Thread.current[:sidekiq_context] = orig_context
+    end
+
+    def self.current
+      Thread.current[:sidekiq_context] ||= {}
+    end
+
+    def self.add(k, v)
+      current[k] = v
+    end
+  end
+
+  class Logger < ::Logger
+    module Formatters
+      class Base < ::Logger::Formatter
+        COLORS = {
+          "DEBUG" => "\e[1;32mDEBUG\e[0m", # green
+          "INFO" => "\e[1;34mINFO \e[0m", # blue
+          "WARN" => "\e[1;33mWARN \e[0m", # yellow
+          "ERROR" => "\e[1;31mERROR\e[0m", # red
+          "FATAL" => "\e[1;35mFATAL\e[0m" # pink
+        }
+
+        def tid
+          Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
+        end
+
+        def format_context(ctxt = Sidekiq::Context.current)
+          (ctxt.size == 0) ? "" : " #{ctxt.map { |k, v|
+            case v
+            when Array
+              "#{k}=#{v.join(",")}"
+            else
+              "#{k}=#{v}"
+            end
+          }.join(" ")}"
+        end
+      end
+
+      class Pretty < Base
+        def call(severity, time, program_name, message)
+          "#{COLORS[severity]} #{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
+        end
+      end
+
+      class Plain < Base
+        def call(severity, time, program_name, message)
+          "#{severity} #{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
+        end
+      end
+
+      class WithoutTimestamp < Pretty
+        def call(severity, time, program_name, message)
+          "#{COLORS[severity]} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{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 = Sidekiq::Context.current
+          hash["ctx"] = c unless c.empty?
+
+          Sidekiq.dump_json(hash) << "\n"
+        end
+      end
+    end
+  end
+end

data/sidekiq-8.1.6/lib/sidekiq/manager.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "sidekiq/processor"
+
+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 Sidekiq::Component
+
+    attr_reader :workers
+    attr_reader :capsule
+
+    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
+    end
+
+    def start
+      @workers.each(&:start)
+    end
+
+    def quiet
+      return if @done
+      @done = true
+
+      logger.info { "Terminating quiet threads for #{capsule.name} capsule" }
+      @workers.each(&:terminate)
+    end
+
+    def stop(deadline)
+      quiet
+
+      # 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 jobs to finish..." }
+      wait_for(deadline) { @workers.empty? }
+      return if @workers.empty?
+
+      hard_shutdown
+    ensure
+      capsule.stop
+    end
+
+    def processor_result(processor, reason = nil)
+      @plock.synchronize do
+        @workers.delete(processor)
+        if !@done && @count > @workers.size
+          p = Processor.new(@config, &method(:processor_result))
+          @workers << p
+          p.start
+        end
+      end
+      nil
+    end
+
+    def stopped?
+      @done
+    end
+
+    private
+
+    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
+
+      if cleanup.size > 0
+        jobs = cleanup.map { |p| p.job }.compact
+
+        logger.warn { "Terminating #{cleanup.size} busy threads" }
+        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
+        # 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
+
+      cleanup.each do |processor|
+        processor.kill
+      end
+
+      # 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
+
+    # 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