sidekiq_alive 2.3.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63e0e0239c3b38ded118c8bd79cfda8e45417b7be5aa4c3b19243bfc8490ddc3
-  data.tar.gz: e263a81dd897da3db9f5a84a79cab8353027e689da700b8871c1226ee68d8da5
+  metadata.gz: 785267eeba9c94f17b29d9df50a17aaa787bfa32b321dc3c097c5d375fc68ef7
+  data.tar.gz: ace6c8c8b8285b3a4963db034a7ab439594adb4123db4957829ca81b3677c07b
 SHA512:
-  metadata.gz: 88782bc7948ceeadc8ee7b2cb8c06cc9c5021da5891e4f333d620c5769a87c120d140cb1374c8886f3881b2c9019ff1855eb4710a838b085adbcc9f8681e3673
-  data.tar.gz: ce6c00b601cc2304568857c7d252a6a7b19693d7e71e6ad7c39f1381b99f8e010cbba91a1195bf073b1381ce0fc3d13cb6c1a736a21e8295fb2291fd485060fb
+  metadata.gz: 51c04d062e6e2bdbdb6bdbcd803024d642847c3a4fe46df673790cc76b1ce1916aae2f90069bc00fd727242b5956ae9646fb52fa227869a08065099a8a09cd95
+  data.tar.gz: 3afc2cd02f1b64e68e99e06a556c9c8aaafff5f717f9fd91370b70fb239834bfcf3626819e6e19a054e50ba29bf977503848e4a02aa306727c1b68b79c391815

data/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,13 +260,6 @@ 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.
@@ -276,6 +267,25 @@ SidekiqAlive.setup do |config|
   # 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
 ```
 

data/lib/sidekiq_alive/config.rb

@@ -12,11 +12,12 @@ module SidekiqAlive
                   :callback,
                   :registered_instance_key,
                   :queue_prefix,
-                  :server,
                   :custom_liveness_probe,
                   :logger,
                   :shutdown_callback,
-                  :concurrency
+                  :concurrency,
+                  :server,
+                  :quiet_timeout
 
     def initialize
       set_defaults
@@ -31,14 +32,19 @@ module SidekiqAlive
       @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
       @registration_ttl || time_to_live * 3
     end
+
+    def worker_interval
+      time_to_live / 2
+    end
   end
 end

data/lib/sidekiq_alive/helpers.rb

@@ -17,11 +17,37 @@ module SidekiqAlive
           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

data/lib/sidekiq_alive/redis/redis_client_gem.rb

@@ -7,10 +7,10 @@ module SidekiqAlive
     # 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:)

data/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

data/lib/sidekiq_alive/server/base.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SidekiqAlive
+  module Server
+    module Base
+      SHUTDOWN_SIGNAL = "TERM"
+      QUIET_SIGNAL = "TSTP"
+
+      # set web server to quiet mode
+      def quiet!
+        logger.info("[SidekiqAlive] Setting web server to quiet mode")
+        Process.kill(QUIET_SIGNAL, @server_pid) unless @server_pid.nil?
+      end
+
+      private
+
+      def configure_shutdown
+        Kernel.at_exit do
+          next if @server_pid.nil?
+
+          logger.info("Shutting down SidekiqAlive web server")
+          Process.kill(SHUTDOWN_SIGNAL, @server_pid)
+          Process.wait(@server_pid)
+        end
+      end
+
+      def configure_shutdown_signal(&block)
+        Signal.trap(SHUTDOWN_SIGNAL, &block)
+      end
+
+      def configure_quiet_signal(&block)
+        Signal.trap(QUIET_SIGNAL, &block)
+      end
+
+      def host
+        SidekiqAlive.config.host
+      end
+
+      def port
+        SidekiqAlive.config.port.to_i
+      end
+
+      def path
+        SidekiqAlive.config.path
+      end
+
+      def logger
+        SidekiqAlive.logger
+      end
+    end
+  end
+end

data/lib/sidekiq_alive/server/default.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "http_server"
+require_relative "base"
+
+module SidekiqAlive
+  module Server
+    class Default < HttpServer
+      extend Base
+
+      class << self
+        def run!
+          logger.info("[SidekiqAlive] Starting default healthcheck server on #{host}:#{port}")
+          @server_pid = ::Process.fork do
+            @server = new(port, host, path)
+            # stop is wrapped in a thread because gserver calls synchrnonize which raises an error when in trap context
+            configure_shutdown_signal { Thread.new { @server.stop } }
+            configure_quiet_signal { @server.quiet! }
+
+            @server.start
+            @server.join
+          end
+          configure_shutdown
+          logger.info("[SidekiqAlive] Web server started in subprocess with pid #{@server_pid}")
+
+          self
+        end
+      end
+
+      def initialize(port, host, path, logger = SidekiqAlive.logger)
+        super(self, port, host, logger)
+
+        @path = path
+      end
+
+      def request_handler(req, res)
+        if req.path != path
+          res.status = 404
+          res.body = "Not found"
+          return logger.warn("[SidekiqAlive] Path '#{req.path}' not found")
+        end
+
+        if quiet?
+          res.status = 200
+          res.body = "Server is shutting down"
+          return logger.debug("[SidekiqAlive] Server in quiet mode, skipping alive key lookup!")
+        end
+
+        if SidekiqAlive.alive?
+          res.status = 200
+          res.body = "Alive!"
+          return logger.debug("[SidekiqAlive] Found alive key!")
+        end
+
+        response = "Can't find the alive key"
+        res.status = 404
+        res.body = response
+        logger.error("[SidekiqAlive] #{response}")
+      rescue StandardError => e
+        response = "Internal Server Error"
+        res.status = 500
+        res.body = response
+        logger.error("[SidekiqAlive] #{response} looking for alive key. Error: #{e.message}")
+      end
+
+      def quiet!
+        @quiet = Time.now
+      end
+
+      private
+
+      attr_reader :path
+
+      def quiet?
+        @quiet && (Time.now - @quiet) < SidekiqAlive.config.quiet_timeout
+      end
+    end
+  end
+end

data/lib/sidekiq_alive/server/http_server.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "gserver"
+
+module SidekiqAlive
+  module Server
+    # Simple HTTP server implementation
+    #
+    class HttpServer < GServer
+      # Request class for HTTP server
+      #
+      class Request
+        attr_reader :data, :header, :method, :path, :proto
+
+        def initialize(data, method = nil, path = nil, proto = nil)
+          @header = {}
+          @data = data
+          @method = method
+          @path = path
+          @proto = proto
+        end
+
+        def content_length
+          len = @header["Content-Length"]
+          return if len.nil?
+
+          len.to_i
+        end
+      end
+
+      # Response class for HTTP server
+      #
+      class Response
+        attr_reader   :header
+        attr_accessor :body, :status, :status_message
+
+        def initialize(status = 200)
+          @status = status
+          @status_message = nil
+          @header = {}
+        end
+      end
+
+      def initialize(handle_obj, port, host, logger = Logger.new($stdout))
+        @handler = handle_obj
+        @logger = logger
+
+        super(port, host, 1, nil, logger.debug?, logger.debug?)
+      end
+
+      private
+
+      attr_reader :handler, :logger
+
+      CRLF        = "\r\n"
+      HTTP_PROTO  = "HTTP/1.1"
+      SERVER_NAME = "SidekiqAlive/#{SidekiqAlive::VERSION} (Ruby/#{RUBY_VERSION})"
+
+      # Default header for the server name
+      DEFAULT_HEADER = {
+        "Server" => SERVER_NAME,
+      }
+
+      # Mapping of status codes and error messages
+      STATUS_CODE_MAPPING = {
+        200 => "OK",
+        400 => "Bad Request",
+        403 => "Forbidden",
+        404 => "Not Found",
+        405 => "Method Not Allowed",
+        411 => "Length Required",
+        500 => "Internal Server Error",
+      }
+
+      def serve(io)
+        # parse first line
+        if io.gets =~ /^(\S+)\s+(\S+)\s+(\S+)/
+          request = Request.new(io, ::Regexp.last_match(1), ::Regexp.last_match(2), ::Regexp.last_match(3))
+        else
+          io << http_resp(status_code: 400)
+          return
+        end
+
+        # parse HTTP headers
+        while (line = io.gets) !~ /^(\n|\r)/
+          if line =~ /^([\w-]+):\s*(.*)$/
+            request.header[::Regexp.last_match(1)] = ::Regexp.last_match(2).strip
+          end
+        end
+
+        io.binmode
+        response = Response.new
+
+        # execute request handler
+        handler.request_handler(request, response)
+
+        http_response = http_resp(
+          status_code: response.status,
+          status_message: response.status_message,
+          header: response.header,
+          body: response.body,
+        )
+
+        # write response back to the client
+        io << http_response
+      rescue StandardError
+        io << http_resp(status_code: 500)
+      end
+
+      def http_header(header = nil)
+        new_header = DEFAULT_HEADER.dup
+        new_header.merge(header) unless header.nil?
+
+        new_header["Connection"] = "Keep-Alive"
+        new_header["Date"] = http_date(Time.now)
+
+        new_header
+      end
+
+      def http_resp(status_code:, status_message: nil, header: nil, body: nil)
+        status_message ||= STATUS_CODE_MAPPING[status_code]
+        status_line = "#{HTTP_PROTO} #{status_code} #{status_message}".rstrip + CRLF
+
+        resp_header = http_header(header)
+        resp_header["Content-Length"] = body.bytesize.to_s unless body.nil?
+        header_lines = resp_header.map { |k, v| "#{k}: #{v}#{CRLF}" }.join
+
+        [status_line, header_lines, CRLF, body].compact.join
+      end
+
+      def http_date(a_time)
+        a_time.gmtime.strftime("%a, %d %b %Y %H:%M:%S GMT")
+      end
+
+      def log(msg)
+        logger.debug(msg)
+      end
+    end
+  end
+end

data/lib/sidekiq_alive/server/rack.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module SidekiqAlive
+  module Server
+    class Rack
+      extend Base
+
+      class << self
+        def run!
+          logger.info("[SidekiqAlive] Starting healthcheck '#{server}' server")
+          @server_pid = ::Process.fork do
+            @handler = handler
+            configure_shutdown_signal { @handler.shutdown }
+            configure_quiet_signal { @quiet = Time.now }
+
+            @handler.run(self, Port: port, Host: host, AccessLog: [], Logger: logger)
+          end
+          configure_shutdown
+
+          self
+        end
+
+        def call(env)
+          req = ::Rack::Request.new(env)
+
+          if req.path != path
+            logger.warn("[SidekiqAlive] Path '#{req.path}' not found")
+            return [404, {}, ["Not found"]]
+          end
+
+          if quiet?
+            logger.debug("[SidekiqAlive] [SidekiqAlive] Server in quiet mode, skipping alive key lookup!")
+            return [200, {}, ["Server is shutting down"]]
+          end
+
+          if SidekiqAlive.alive?
+            logger.debug("[SidekiqAlive] Found alive key!")
+            return [200, {}, ["Alive!"]]
+          end
+
+          response = "Can't find the alive key"
+          logger.error("[SidekiqAlive] #{response}")
+          [404, {}, [response]]
+        rescue StandardError => e
+          logger.error("[SidekiqAlive] #{response} looking for alive key. Error: #{e.message}")
+          [500, {}, ["Internal Server Error"]]
+        end
+
+        private
+
+        def quiet?
+          @quiet && (Time.now - @quiet) < SidekiqAlive.config.quiet_timeout
+        end
+
+        def handler
+          Helpers.use_rackup? ? ::Rackup::Handler.get(server) : ::Rack::Handler.get(server)
+        end
+
+        def server
+          SidekiqAlive.config.server
+        end
+      end
+    end
+  end
+end

data/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"

data/lib/sidekiq_alive/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SidekiqAlive
-  VERSION = "2.3.1"
+  VERSION = "2.5.0"
 end

data/lib/sidekiq_alive/worker.rb

@@ -12,8 +12,9 @@ module SidekiqAlive
 
       # Writes the liveness in Redis
       write_living_probe
+      remove_orphaned_queues
       # schedules next living probe
-      self.class.perform_in(config.time_to_live / 2, current_hostname)
+      self.class.perform_in(config.worker_interval, current_hostname)
     end
 
     def write_living_probe
@@ -29,6 +30,17 @@ module SidekiqAlive
       end
     end
 
+    # Removes orphaned Sidekiq queues left behind by unexpected instance shutdowns (e.g., due to OOM)
+    def remove_orphaned_queues
+      # If the worker isn't executed within this window, the lifeness key expires
+      latency_threshold = config.time_to_live - config.worker_interval
+      Sidekiq::Queue.all
+        .filter { |q| q.name.start_with?(config.queue_prefix.to_s) }
+        .filter { |q| q.latency > latency_threshold }
+        .filter { |q| q.size == 1 && q.all? { |job| job.klass == self.class.name } }
+        .each(&:clear)
+    end
+
     def current_hostname
       SidekiqAlive.hostname
     end

data/lib/sidekiq_alive.rb

@@ -27,28 +27,28 @@ module SidekiqAlive
             (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 @@ module SidekiqAlive
       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 @@ module SidekiqAlive
       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
@@ -150,7 +148,7 @@ module SidekiqAlive
     end
 
     def successful_startup_text
-      "Successfully started sidekiq-alive, registered with key: "\
+      "Successfully started sidekiq-alive, registered with key: " \
         "#{current_instance_register_key} on set #{HOSTNAME_REGISTRY}"
     end
 

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq_alive
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.5.0
 platform: ruby
 authors:
 - Andrejs Cunskis
 - Artur Pañach
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-17 00:00:00.000000000 Z
+date: 2025-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -39,20 +39,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: rack-test
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.1.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -87,14 +73,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: rubocop-shopify
   requirement: !ruby/object:Gem::Requirement
@@ -110,73 +96,67 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.10'
 - !ruby/object:Gem::Dependency
-  name: solargraph
+  name: semver2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.49.0
+        version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.49.0
+        version: '3.4'
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: solargraph
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
-  type: :runtime
+        version: 0.54.0
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: 0.54.0
 - !ruby/object:Gem::Dependency
-  name: sidekiq
+  name: gserver
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: 0.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: 0.0.1
 - !ruby/object:Gem::Dependency
-  name: webrick
+  name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '5'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '5'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '9'
 description: |
   SidekiqAlive offers a solution to add liveness probe of a Sidekiq instance.
 
@@ -204,6 +184,10 @@ files:
 - lib/sidekiq_alive/redis/redis_client_gem.rb
 - lib/sidekiq_alive/redis/redis_gem.rb
 - lib/sidekiq_alive/server.rb
+- lib/sidekiq_alive/server/base.rb
+- lib/sidekiq_alive/server/default.rb
+- lib/sidekiq_alive/server/http_server.rb
+- lib/sidekiq_alive/server/rack.rb
 - lib/sidekiq_alive/version.rb
 - lib/sidekiq_alive/worker.rb
 homepage: https://github.com/arturictus/sidekiq_alive
@@ -213,9 +197,9 @@ metadata:
   homepage_uri: https://github.com/arturictus/sidekiq_alive
   source_code_uri: https://github.com/arturictus/sidekiq_alive
   changelog_uri: https://github.com/arturictus/sidekiq_alive/releases
-  documentation_uri: https://github.com/arturictus/sidekiq_alive/blob/v2.3.1/README.md
+  documentation_uri: https://github.com/arturictus/sidekiq_alive/blob/v2.5.0/README.md
   bug_tracker_uri: https://github.com/arturictus/sidekiq_alive/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -223,15 +207,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Liveness probe for sidekiq on Kubernetes deployments.
 test_files: []