.github/workflows/test.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - name: Set up Ruby ${{ matrix.ruby-version }}
+      - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
           bundler-cache: true
@@ -38,13 +38,13 @@ jobs:
           - 6379:6379
     steps:
       - uses: actions/checkout@v4
-      - name: Set up Ruby ${{ matrix.ruby-version }}
+      - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
           bundler-cache: true
           cache-version: 1
       - name: Run tests
-        run: bundle exec rspec
+        run: bundle exec rspec --force-color
       # - name: Code Coverage Summary
       #   uses: irongut/CodeCoverageSummary@v1.3.0
       #   with:
@@ -69,8 +69,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: ["3.2", "3.1", "3.0", "2.7"]
-        sidekiq-version: ["~> 5.2", "~> 6.5", "~> 7"]
+        ruby-version: ["3.2", "3.1", "3.0"]
+        sidekiq-version: ["~> 6.5", "~> 7"]
+        with-rackup: [true, false]
     # Service containers to run with `runner-job`
     services:
       # Label used to access the service container
@@ -86,7 +87,6 @@ jobs:
         ports:
           # Maps port 6379 on service container to the host
           - 6379:6379
-
     steps:
       - uses: actions/checkout@v4
       - name: Set up Ruby ${{ matrix.ruby-version }} with Sidekiq ${{ matrix.sidekiq-version }}
@@ -97,5 +97,9 @@ jobs:
           cache-version: 1
         env:
           SIDEKIQ_VERSION_RANGE: ${{ matrix.sidekiq-version }}
+          WITH_RACKUP: ${{ matrix.with-rackup }}
       - name: Run tests
         run: bundle exec rspec --force-color
+        env:
+          SIDEKIQ_VERSION_RANGE: ${{ matrix.sidekiq-version }}
+          WITH_RACKUP: ${{ matrix.with-rackup }}

Gemfile

@@ -9,6 +9,19 @@ gemspec
 
 gem "sidekiq", ENV["SIDEKIQ_VERSION_RANGE"] || "< 8"
 
-gem "ruby-lsp", "~> 0.5.1", group: :development
-gem "simplecov", require: false, group: :test
-gem "simplecov-cobertura"
+gem "ruby-lsp", "~> 0.14.0", group: :development
+
+group :test do
+  gem "simplecov", require: false
+  gem "simplecov-cobertura"
+
+  # used for testing rack based server
+  gem "rack-test", "~> 2.1.0"
+  # rackup is not compatible with sidekiq < 7 due to rack version requirement
+  if ENV["WITH_RACKUP"] == "true" && ["7", "8"].any? { |range| ENV["SIDEKIQ_VERSION_RANGE"]&.include?(range) }
+    gem "rackup", "~> 2.1.0"
+  else
+    gem "rack", "< 3"
+    gem "webrick", "< 2"
+  end
+end

README.md

@@ -247,12 +247,10 @@ SidekiqAlive.setup do |config|
   #    config.callback = proc { Net::HTTP.get("https://status.com/ping") }
 
   # ==> Shutdown callback
-  # When sidekiq process is shutting down, you can perform some action, like cleaning up created queue
+  # When sidekiq process is shutting down, you can perform some arbitrary action.
   # default: proc {}
   #
-  #    config.shutdown_callback = proc do
-  #      Sidekiq::Queue.all.find { |q| q.name == "#{config.queue_prefix}-#{SidekiqAlive.hostname}" }&.clear
-  #    end
+  #    config.shutdown_callback = proc { puts "Sidekiq is shutting down" }
 
   # ==> Queue Prefix
   # SidekiqAlive will run in a independent queue for each instance/replica
@@ -262,20 +260,32 @@ SidekiqAlive.setup do |config|
   #
   #    config.queue_prefix = :other
 
-  # ==> Rack server
-  # Web server used to serve an HTTP response.
-  # Can also be set with the environment variable SIDEKIQ_ALIVE_SERVER.
-  # default: 'webrick'
-  #
-  #    config.server = 'puma'
-
   # ==> Concurrency
   # The maximum number of Redis connections requested for the SidekiqAlive pool.
   # Can also be set with the environment variable SIDEKIQ_ALIVE_CONCURRENCY.
   # NOTE: only effects Sidekiq 7 or greater.
   # default: 2
   #
   #    config.concurrency = 3
+
+  # ==> Rack server
+  # Web server used to serve an HTTP response. By default simple GServer based http server is used.
+  # To use specific server, rack gem version > 2 is required. For rack version >= 3, rackup gem is required.
+  # Can also be set with the environment variable SIDEKIQ_ALIVE_SERVER.
+  # default: nil
+  #
+  #    config.server = 'puma'
+
+  # ==> Quiet mode timeout in seconds
+  # When sidekiq is shutting down, the Sidekiq process stops pulling jobs from the queue. This includes alive key update job. In case of
+  # long running jobs, alive key can expire before the job is finished. To avoid this, web server is set in to quiet mode
+  # and is returning 200 OK for healthcheck requests. To avoid infinite quiet mode in case sidekiq process is stuck in shutdown,
+  # timeout can be set. After timeout is reached, web server resumes normal operations and will return unhealthy status in case
+  # alive key is expired or purged from redis.
+  # default: 180
+  #
+  #    config.quiet_timeout = 300
+
 end
 ```
 

lib/sidekiq_alive.rb

@@ -27,28 +27,28 @@ def start
             (sq_config.respond_to?(:[]) ? sq_config[:queues] : sq_config.options[:queues]).unshift(current_queue)
           end
 
-          logger.info(startup_info)
-
+          logger.info("[SidekiqAlive] #{startup_info}")
           register_current_instance
-
           store_alive_key
           # Passing the hostname argument it's only for debugging enqueued jobs
           SidekiqAlive::Worker.perform_async(hostname)
-          @server_pid = fork { SidekiqAlive::Server.run! }
+          @server = SidekiqAlive::Server.run!
 
-          logger.info(successful_startup_text)
+          logger.info("[SidekiqAlive] #{successful_startup_text}")
         end
 
         sq_config.on(:quiet) do
-          unregister_current_instance
-          config.shutdown_callback.call
+          logger.info("[SidekiqAlive] #{shutdown_info}")
+          purge_pending_jobs
+          # set web server to quiet mode
+          @server&.quiet!
         end
 
         sq_config.on(:shutdown) do
-          Process.kill("TERM", @server_pid) unless @server_pid.nil?
-          Process.wait(@server_pid) unless @server_pid.nil?
-
-          unregister_current_instance
+          remove_queue
+          # make sure correct redis connection pool is used
+          # sidekiq will terminate non internal capsules
+          Redis.adapter("internal").zrem(HOSTNAME_REGISTRY, current_instance_register_key)
           config.shutdown_callback.call
         end
       end
@@ -62,13 +62,6 @@ def register_current_instance
       register_instance(current_instance_register_key)
     end
 
-    def unregister_current_instance
-      # Delete any pending jobs for this instance
-      logger.info(shutdown_info)
-      purge_pending_jobs
-      redis.zrem(HOSTNAME_REGISTRY, current_instance_register_key)
-    end
-
     def registered_instances
       # before we return we make sure we expire old keys
       expire_old_keys
@@ -82,9 +75,14 @@ def purge_pending_jobs
       else
         schedule_set.scan('"class":"SidekiqAlive::Worker"').select { |job| job.queue == current_queue }
       end
-      logger.info("[SidekiqAlive] Purging #{jobs.count} pending for #{hostname}")
-      jobs.each(&:delete)
 
+      unless jobs.empty?
+        logger.info("[SidekiqAlive] Purging #{jobs.count} pending jobs for #{hostname}")
+        jobs.each(&:delete)
+      end
+    end
+
+    def remove_queue
       logger.info("[SidekiqAlive] Removing queue #{current_queue}")
       Sidekiq::Queue.new(current_queue).clear
     end

lib/sidekiq_alive/config.rb

@@ -12,11 +12,12 @@ class Config
                   :callback,
                   :registered_instance_key,
                   :queue_prefix,
-                  :server,
                   :custom_liveness_probe,
                   :logger,
                   :shutdown_callback,
-                  :concurrency
+                  :concurrency,
+                  :server,
+                  :quiet_timeout
 
     def initialize
       set_defaults
@@ -31,10 +32,11 @@ def set_defaults
       @callback = proc {}
       @registered_instance_key = "SIDEKIQ_REGISTERED_INSTANCE"
       @queue_prefix = :"sidekiq-alive"
-      @server = ENV.fetch("SIDEKIQ_ALIVE_SERVER", "webrick")
       @custom_liveness_probe = proc { true }
       @shutdown_callback = proc {}
       @concurrency = Integer(ENV.fetch("SIDEKIQ_ALIVE_CONCURRENCY", 2), exception: false) || 2
+      @server = ENV.fetch("SIDEKIQ_ALIVE_SERVER", nil)
+      @quiet_timeout = Integer(ENV.fetch("SIDEKIQ_ALIVE_QUIET_TIMEOUT", 180), exception: false) || 180
     end
 
     def registration_ttl

lib/sidekiq_alive/helpers.rb

@@ -17,11 +17,37 @@ def sidekiq_5
           current_sidekiq_version < Gem::Version.new("6")
       end
 
+      def use_rack?
+        return @use_rack if defined?(@use_rack)
+
+        require "rack"
+        @use_rack = current_rack_version < Gem::Version.new("3")
+      rescue LoadError
+        # currently this won't happen because rack is a dependency of sidekiq
+        @use_rack = false
+      end
+
+      def use_rackup?
+        return @use_rackup if defined?(@use_rackup)
+
+        require "rackup"
+        @use_rackup = current_rack_version >= Gem::Version.new("3")
+      rescue LoadError
+        if current_rack_version >= Gem::Version.new("3")
+          SidekiqAlive.logger.warn("rackup gem required with rack >= 3, defaulting to default server")
+        end
+        @use_rackup = false
+      end
+
       private
 
       def current_sidekiq_version
         Gem.loaded_specs["sidekiq"].version
       end
+
+      def current_rack_version
+        Gem.loaded_specs["rack"].version
+      end
     end
   end
 end

lib/sidekiq_alive/redis.rb

@@ -3,8 +3,8 @@
 module SidekiqAlive
   module Redis
     class << self
-      def adapter
-        Helpers.sidekiq_7 ? Redis::RedisClientGem.new : Redis::RedisGem.new
+      def adapter(capsule = nil)
+        Helpers.sidekiq_7 ? Redis::RedisClientGem.new(capsule) : Redis::RedisGem.new
       end
     end
   end

lib/sidekiq_alive/redis/redis_client_gem.rb

@@ -7,10 +7,10 @@ module Redis
     # Wrapper for `redis-client` gem used by `sidekiq` > 7
     # https://github.com/redis-rb/redis-client
     class RedisClientGem < Base
-      def initialize
-        super
+      def initialize(capsule = nil)
+        super()
 
-        @capsule = Sidekiq.default_configuration.capsules[CAPSULE_NAME]
+        @capsule = Sidekiq.default_configuration.capsules[capsule || CAPSULE_NAME]
       end
 
       def set(key, time:, ex:)

lib/sidekiq_alive/server.rb

@@ -1,45 +1,30 @@
 # frozen_string_literal: true
 
-require "rack"
-
 module SidekiqAlive
-  class Server
+  module Server
     class << self
       def run!
-        handler = Rack::Handler.get(server)
-
-        Signal.trap("TERM") { handler.shutdown }
-
-        handler.run(self, Port: port, Host: host, AccessLog: [], Logger: SidekiqAlive.logger)
+        server.run!
       end
 
-      def host
-        SidekiqAlive.config.host
-      end
+      private
 
-      def port
-        SidekiqAlive.config.port
+      def server
+        use_rack? ? Rack : Default
       end
 
-      def path
-        SidekiqAlive.config.path
-      end
+      def use_rack?
+        return false unless SidekiqAlive.config.server
 
-      def server
-        SidekiqAlive.config.server
+        Helpers.use_rackup? || Helpers.use_rack?
       end
 
-      def call(env)
-        if Rack::Request.new(env).path != path
-          [404, {}, ["Not found"]]
-        elsif SidekiqAlive.alive?
-          [200, {}, ["Alive!"]]
-        else
-          response = "Can't find the alive key"
-          SidekiqAlive.logger.error(response)
-          [404, {}, [response]]
-        end
+      def logger
+        SidekiqAlive.logger
       end
     end
   end
 end
+
+require_relative "server/default"
+require_relative "server/rack"