sidekiq_alive 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 562294aa960a1c1cd11b0a020b0f7cce26f09ee4c2faeb7044e21fd9bf3be8c5
-  data.tar.gz: c31918f4c756cc551a3dcab2ea0d2c781c394e23e463c0a2c72ae68bfb52cd16
+  metadata.gz: 203a0459203c7e31aa2a223c7a6a2eea009f109697843b83eacd73577606487b
+  data.tar.gz: b85f281d7fc890744c303a51c46bdd846c3101e0acd44f3557a3549a00f25807
 SHA512:
-  metadata.gz: 595baafc8b0499bb8f900cdaf3eac250d623ba3b51d65b4510d311b2913b1e0560fc967c63dbeaf9145cab43527a5d133b7af6127492103e0caf8538b61ed55e
-  data.tar.gz: 05deade6b05eb839fb0c6d1c0d08768b2141cc24c61cdd2edc1aa453338b12bc7b5bce3a8d19692968a7f85939541519fb6c70eb759273c1b2fe5afffce8b413
+  metadata.gz: e2ab4467ab2b6041c4858fd96b91e5172751b4f86af6d6f4846d8e1f86f158a0a3279153e5972e24636d46983f5811191ea83ed4993e18886fda99ff206bec26
+  data.tar.gz: 2fe20f2e4895506137ba6e4ec6afe3c544eab32eef4a9a31690db808f459e452012ed3646d69c24dec869a2519facc6d9909326af915fe723126b8e212960f5a

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,12 +260,32 @@ SidekiqAlive.setup do |config|
   #
   #    config.queue_prefix = :other
 
+  # ==> 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.
+  # 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: 'webrick'
+  # 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,10 +12,12 @@ module SidekiqAlive
                   :callback,
                   :registered_instance_key,
                   :queue_prefix,
-                  :server,
                   :custom_liveness_probe,
                   :logger,
-                  :shutdown_callback
+                  :shutdown_callback,
+                  :concurrency,
+                  :server,
+                  :quiet_timeout
 
     def initialize
       set_defaults
@@ -30,9 +32,11 @@ 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

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 = "USR1"
+
+      # 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 && (@quiet - Time.now) < 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 && (@quiet - Time.now) < 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.0"
+  VERSION = "2.4.0"
 end

data/lib/sidekiq_alive.rb

@@ -20,35 +20,35 @@ module SidekiqAlive
 
           if Helpers.sidekiq_7
             sq_config.capsule(CAPSULE_NAME) do |cap|
-              cap.concurrency = 2
+              cap.concurrency = config.concurrency
               cap.queues = [current_queue]
             end
           else
             (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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq_alive
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Andrejs Cunskis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-07 00:00:00.000000000 Z
+date: 2024-02-15 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
@@ -115,28 +101,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.49.0
+        version: 0.50.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.49.0
+        version: 0.50.0
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: gserver
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: 0.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3'
+        version: 0.0.1
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
@@ -157,26 +143,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
-- !ruby/object:Gem::Dependency
-  name: webrick
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
 description: |
   SidekiqAlive offers a solution to add liveness probe of a Sidekiq instance.
 
@@ -204,6 +170,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,7 +183,7 @@ 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.0/README.md
+  documentation_uri: https://github.com/arturictus/sidekiq_alive/blob/v2.4.0/README.md
   bug_tracker_uri: https://github.com/arturictus/sidekiq_alive/issues
 post_install_message: 
 rdoc_options: []