sidekiq_alive simple alternative implementation (gem sidekiq_status_monitor)

sidekiq_alive.rb

# PATH: config/initializers/sidekiq_alive.rb
# AUTHOR: Andrei Makarov (github.com/amkisko)

# NOTE: now available as gem sidekiq_status_monitor (https://rubygems.org/gems/sidekiq_status_monitor)

class SidekiqAliveServer
  attr_accessor :workers_size_threshold,
                :process_set_size_threshold,
                :queues_size_threshold,
                :queue_latency_threshold,
                :queue_size_threshold

  def initialize(host: nil, port: nil, engine: nil, logger: nil)
    @host = host || "0.0.0.0"
    @port = port || 7433
    @engine = engine || "thin"
    @logger = logger || Rails.logger

    @workers_size_threshold = 0
    @process_set_size_threshold = 1
    @queues_size_threshold = 1
    @queue_latency_threshold = 30 * 60
    @queue_size_threshold = 1_000_000
  end

  def run!
    handler = Rack::Handler.get(@engine)
    Signal.trap("TERM") { handler.shutdown }
    handler.run(self, Port: @port, Host: @host, AccessLog: [], Logger: @logger)
  end

  delegate :size, to: :workers, prefix: true
  def workers
    Sidekiq::Workers.new
  end

  delegate :size, to: :process_set, prefix: true
  def process_set
    Sidekiq::ProcessSet.new
  end

  delegate :size, to: :queues, prefix: true
  def queues
    Sidekiq::Queue.all
  end

  def queues_avg_latency
    queues.sum(&:latency) / queues_size if queues_size&.positive?
  end

  def queues_avg_size
    queues.sum(&:size) / queues_size if queues_size&.positive?
  end

  def queues_names
    queues.map(&:name).uniq.sort
  end

  def alive?
    [
      workers_size && workers_size >= workers_size_threshold,
      process_set_size && process_set_size >= process_set_size_threshold,
      queues_size && queues_size >= queues_size_threshold,
      queues_avg_latency && queues_avg_latency < queue_latency_threshold,
      queues_avg_size && queues_avg_size < queue_size_threshold
    ].all?
  end

  def call(_env)
    [
      alive? ? 200 : 500,
      { "Content-Type" => "application/json" },
      [
        {
          workers_size: workers_size,
          process_set_size: process_set_size,
          queues_size: queues_size,
          queues_avg_latency: queues_avg_latency,
          queues_avg_size: queues_avg_size
        }.to_json
      ]
    ]
  end
end

Sidekiq.configure_server do |config|
  config.on(:startup) { @server_pid = fork { SidekiqAliveServer.new.run! } }

  config.on(:quiet) {}

  config.on(:shutdown) do
    Process.kill("TERM", @server_pid) unless @server_pid.nil?
    Process.wait(@server_pid) unless @server_pid.nil?
  end
end