sidekiq-alive-next 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '011966672fb70c9dcb73ae34518c7cce7efef6860f508133c75bf16e800142c7'
-  data.tar.gz: e68981042be3956bdf98062eef749409996f92b0ebfe7db7cf7f0c545136db88
+  metadata.gz: 8cbf2184e5b001d067c1a79b65daf927182fd132ca2554177e31a7f070176e12
+  data.tar.gz: e911131239e815e146bc66b6844f092571d07108ff6ae27ed2d730d39a49928a
 SHA512:
-  metadata.gz: 8b6c58b34ce76fd9db659e77bb2e0b97c8a3dfe46c7c65182f2bbf9116f02f227f806fe594190a05a247849c64136883dbc18fd66bb6ee9b8882d02e6175b3e3
-  data.tar.gz: ea118c1bac0605335b712273b071364781753820bd83070f99f7bea48193949208d2bb505d1ac0d047ea9dc1c4c65d80bcba7cd298c37c37a9bf77e0b4f978d0
+  metadata.gz: 1a0ddb8c2bdd70be93b63659711967f617e7b4b4f84bc695646baa331c7de188ed3993ea30530a54dfb12dfcfbd374dd3b8a0a54e350b038a6e09bb10e18cb47
+  data.tar.gz: 551e3c7c103eb1c3067e1ad8084db084872817f30b14d58e9658b348c220e064b20f5b4352f60507372ace146957765bc2f9c17da6360eb7f20c46aa9b23a507

data/README.md

@@ -5,7 +5,9 @@
 ![Workflow status](https://github.com/allure-framework/allure-ruby/workflows/Test/badge.svg)
 [![Known Vulnerabilities](https://snyk.io/test/github/andrcuns/sidekiq-alive/badge.svg)](https://snyk.io/test/github/andrcuns/sidekiq-alive)
 
-**This is the fork of 'arturictus/sidekiq_alive' with a few minor fixes and tweaks, all credit goes to author of original repo**
+**This is the fork of '[arturictus/sidekiq_alive](https://github.com/arturictus/sidekiq_alive)' with a few minor fixes and tweaks, original implementation credit goes to author of original repo**
+
+---
 
 SidekiqAlive offers a solution to add liveness probe for a Sidekiq instance deployed in Kubernetes.
 This library can be used to check sidekiq health outside kubernetes.
@@ -49,11 +51,15 @@ gem 'sidekiq-alive-next'
 
 And then execute:
 
-    $ bundle
+```console
+bundle
+```
 
 Or install it yourself as:
 
-    $ gem install sidekiq-alive-next
+```console
+gem install sidekiq-alive-next
+```
 
 ## Usage
 
@@ -61,11 +67,11 @@ SidekiqAlive will start when running `sidekiq` command.
 
 Run `Sidekiq`
 
-```
+```console
 bundle exec sidekiq
 ```
 
-```
+```console
 curl localhost:7433
 #=> Alive!
 ```
@@ -74,7 +80,7 @@ curl localhost:7433
 You can disabled by setting `ENV` variable `DISABLE_SIDEKIQ_ALIVE`
 example:
 
-```
+```console
 DISABLE_SIDEKIQ_ALIVE=true bundle exec sidekiq
 ```
 
@@ -137,8 +143,8 @@ kill -SIGTSTP $SIDEKIQ_PID
 
 Make it executable:
 
-```
-$ chmod +x kube/sidekiq_quiet
+```console
+chmod +x kube/sidekiq_quiet
 ```
 
 Execute it in your deployment preStop:
@@ -183,12 +189,12 @@ It's just up to you how you want to use it.
 
 An example in local would be:
 
-```
+```console
 bundle exec sidekiq
 # let it initialize ...
 ```
 
-```
+```console
 curl localhost:7433
 #=> Alive!
 ```
@@ -248,12 +254,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 == "#{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
@@ -263,12 +267,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
 ```
 
@@ -278,11 +302,9 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`.
 
-Here is an example [rails app](https://github.com/arturictus/sidekiq_alive_example)
-
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/andrcuns/sidekiq-alive. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at <https://github.com/andrcuns/sidekiq-alive>. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

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,13 +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 + 60
+      @registration_ttl || time_to_live * 3
+    end
+
+    def worker_interval
+      time_to_live / 2
     end
   end
 end

data/lib/sidekiq_alive/helpers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SidekiqAlive
+  module Helpers
+    class << self
+      def sidekiq_7
+        current_sidekiq_version >= Gem::Version.new("7")
+      end
+
+      def sidekiq_6
+        current_sidekiq_version >= Gem::Version.new("6") &&
+          current_sidekiq_version < Gem::Version.new("7")
+      end
+
+      def sidekiq_5
+        current_sidekiq_version >= Gem::Version.new("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

data/lib/sidekiq_alive/redis/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SidekiqAlive
+  module Redis
+    class Base
+      def set(...)
+        raise(NotImplementedError)
+      end
+
+      def zadd(set_key, ex, key)
+        raise(NotImplementedError)
+      end
+
+      def zrange(set_key, start, stop)
+        raise(NotImplementedError)
+      end
+
+      def zrangebyscore(set_key, min, max)
+        raise(NotImplementedError)
+      end
+
+      def zrem(set_key, key)
+        raise(NotImplementedError)
+      end
+
+      def delete(key)
+        raise(NotImplementedError)
+      end
+
+      def ttl(...)
+        redis { |r| r.ttl(...) }
+      end
+    end
+  end
+end

data/lib/sidekiq_alive/redis/redis_client_gem.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module SidekiqAlive
+  module Redis
+    # Wrapper for `redis-client` gem used by `sidekiq` > 7
+    # https://github.com/redis-rb/redis-client
+    class RedisClientGem < Base
+      def initialize(capsule = nil)
+        super()
+
+        @capsule = Sidekiq.default_configuration.capsules[capsule || CAPSULE_NAME]
+      end
+
+      def set(key, time:, ex:)
+        redis { |r| r.call("SET", key, time, ex: ex) }
+      end
+
+      def get(key)
+        redis { |r| r.call("GET", key) }
+      end
+
+      def zadd(set_key, ex, key)
+        redis { |r| r.call("ZADD", set_key, ex, key) }
+      end
+
+      def zrange(set_key, start, stop)
+        redis { |r| r.call("ZRANGE", set_key, start, stop) }
+      end
+
+      def zrangebyscore(set_key, min, max)
+        redis { |r| r.call("ZRANGEBYSCORE", set_key, min, max) }
+      end
+
+      def zrem(set_key, key)
+        redis { |r| r.call("ZREM", set_key, key) }
+      end
+
+      def delete(key)
+        redis { |r| r.call("DEL", key) }
+      end
+
+      private
+
+      def redis(&block)
+        # Default to Sidekiq.redis if capsule is not configured yet but redis adapter is accessed
+        (@capsule || Sidekiq).redis(&block)
+      end
+    end
+  end
+end

data/lib/sidekiq_alive/redis/redis_gem.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module SidekiqAlive
+  module Redis
+    # Wrapper for `redis` gem used by sidekiq < 7
+    # https://github.com/redis/redis-rb
+    class RedisGem < Base
+      def set(key, time:, ex:)
+        redis { |r| r.set(key, time, ex: ex) }
+      end
+
+      def get(key)
+        redis { |r| r.get(key) }
+      end
+
+      def zadd(set_key, ex, key)
+        redis { |r| r.zadd(set_key, ex, key) }
+      end
+
+      def zrange(set_key, start, stop)
+        redis { |r| r.zrange(set_key, start, stop) }
+      end
+
+      def zrangebyscore(set_key, min, max)
+        redis { |r| r.zrangebyscore(set_key, min, max) }
+      end
+
+      def zrem(set_key, key)
+        redis { |r| r.zrem(set_key, key) }
+      end
+
+      def delete(key)
+        redis { |r| r.del(key) }
+      end
+
+      private
+
+      def redis(&block)
+        Sidekiq.redis(&block)
+      end
+    end
+  end
+end

data/lib/sidekiq_alive/redis.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SidekiqAlive
+  module Redis
+    class << self
+      def adapter(capsule = nil)
+        Helpers.sidekiq_7 ? Redis::RedisClientGem.new(capsule) : Redis::RedisGem.new
+      end
+    end
+  end
+end
+
+require_relative "redis/base"
+require_relative "redis/redis_client_gem"
+require_relative "redis/redis_gem"

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