Add configurable HTTP health-check server

Author: faraquet

README.md

@@ -28,6 +28,7 @@ Solid Queue can be used with SQL databases such as MySQL, PostgreSQL, or SQLite,
 - [Failed jobs and retries](#failed-jobs-and-retries)
   - [Error reporting on jobs](#error-reporting-on-jobs)
 - [Puma plugin](#puma-plugin)
+- [Health-check HTTP server](#health-check-http-server)
 - [Jobs and transactional integrity](#jobs-and-transactional-integrity)
 - [Recurring tasks](#recurring-tasks)
 - [Inspiration](#inspiration)
@@ -603,6 +604,29 @@ that you set in production only. This is what Rails 8's default Puma config look
 
 **Note**: phased restarts are not supported currently because the plugin requires [app preloading](https://github.com/puma/puma?tab=readme-ov-file#cluster-mode) to work.
 
+## Health-check HTTP server
+
+Solid Queue can start a tiny HTTP server to respond to basic health checks in the same process. This is useful for container orchestrators (e.g. Kubernetes) and external monitoring.
+
+- Endpoints:
+  - `/` and `/health`: returns `200 OK` with body `OK`
+  - Any other path: returns `404 Not Found`
+- Disabled by default. When enabled, defaults are:
+  - host: `ENV["SOLID_QUEUE_HTTP_HOST"]` or `"0.0.0.0"`
+  - port: `ENV["SOLID_QUEUE_HTTP_PORT"]` or `9393`
+
+Enable and configure via `config.solid_queue`:
+
+```ruby
+# config/initializers/solid_queue.rb or config/application.rb
+Rails.application.configure do
+  config.solid_queue.health_server_enabled = true
+  # Optional overrides (defaults already read the env vars above)
+  # config.solid_queue.health_server_host = "0.0.0.0"
+  # config.solid_queue.health_server_port = 9393
+end
+```
+
 ## Jobs and transactional integrity
 :warning: Having your jobs in the same ACID-compliant database as your application data enables a powerful yet sharp tool: taking advantage of transactional integrity to ensure some action in your app is not committed unless your job is also committed and vice versa, and ensuring that your job won't be enqueued until the transaction within which you're enqueuing it is committed. This can be very powerful and useful, but it can also backfire if you base some of your logic on this behaviour, and in the future, you move to another active job backend, or if you simply move Solid Queue to its own database, and suddenly the behaviour changes under you. Because this can be quite tricky and many people shouldn't need to worry about it, by default Solid Queue is configured in a different database as the main app.
 

lib/solid_queue.rb

@@ -41,6 +41,10 @@ module SolidQueue
   mattr_accessor :clear_finished_jobs_after, default: 1.day
   mattr_accessor :default_concurrency_control_period, default: 3.minutes
 
+  mattr_accessor :health_server_enabled, default: false
+  mattr_accessor :health_server_host,    default: ENV.fetch("SOLID_QUEUE_HTTP_HOST", "0.0.0.0")
+  mattr_accessor :health_server_port,    default: (ENV["SOLID_QUEUE_HTTP_PORT"] || "9393").to_i
+
   delegate :on_start, :on_stop, :on_exit, to: Supervisor
 
   [ Dispatcher, Scheduler, Worker ].each do |process|

lib/solid_queue/engine.rb

@@ -37,5 +37,22 @@ class Engine < ::Rails::Engine
         include ActiveJob::ConcurrencyControls
       end
     end
+
+    initializer "solid_queue.health_server" do
+      ActiveSupport.on_load(:solid_queue) do
+        if SolidQueue.health_server_enabled
+          server = SolidQueue::HealthServer.new(
+            host: SolidQueue.health_server_host,
+            port: SolidQueue.health_server_port,
+            logger: SolidQueue.logger
+          )
+
+          # Start with supervisor lifecycle so it runs in the main SolidQueue process
+          SolidQueue.on_start { server.start }
+          SolidQueue.on_stop { server.stop }
+          SolidQueue.on_exit { server.stop }
+        end
+      end
+    end
   end
 end

lib/solid_queue/health_server.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "socket"
+require "logger"
+
+module SolidQueue
+  class HealthServer
+    def initialize(host:, port:, logger: nil)
+      @host = host
+      @port = port
+      @logger = logger || default_logger
+      @server = nil
+      @thread = nil
+    end
+
+    def start
+      return if running?
+
+      @thread = Thread.new do
+        begin
+          @server = TCPServer.new(@host, @port)
+          log_info("listening on #{@host}:#{@port}")
+
+          loop do
+            socket = @server.accept
+            begin
+              request_line = socket.gets
+              path = request_line&.split(" ")&.at(1) || "/"
+
+              if path == "/" || path == "/health"
+                body = "OK"
+                status_line = "HTTP/1.1 200 OK"
+              else
+                body = "Not Found"
+                status_line = "HTTP/1.1 404 Not Found"
+              end
+
+              headers = [
+                "Content-Type: text/plain",
+                "Content-Length: #{body.bytesize}",
+                "Connection: close"
+              ].join("\r\n")
+
+              socket.write("#{status_line}\r\n#{headers}\r\n\r\n#{body}")
+            ensure
+              begin
+                socket.close
+              rescue StandardError
+              end
+            end
+          end
+        rescue => e
+          log_error("failed: #{e.class}: #{e.message}")
+        ensure
+          begin
+            @server&.close
+          rescue StandardError
+          end
+        end
+      end
+    end
+
+    def stop
+      return unless running?
+
+      begin
+        @server&.close
+      rescue StandardError
+      end
+
+      if @thread&.alive?
+        @thread.kill
+        @thread.join(1)
+      end
+
+      @server = nil
+      @thread = nil
+    end
+
+    def running?
+      @thread&.alive?
+    end
+
+    private
+
+      def default_logger
+        logger = Logger.new($stdout)
+        logger.level = Logger::INFO
+        logger.progname = "SolidQueueHTTP"
+        logger
+      end
+
+      def log_info(message)
+        @logger&.info(message)
+      end
+
+      def log_error(message)
+        @logger&.error(message)
+      end
+  end
+end

test/unit/health_server_test.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "net/http"
+require "socket"
+
+class HealthServerTest < ActiveSupport::TestCase
+  def setup
+    @host = "127.0.0.1"
+    @port = available_port(@host)
+    @server = SolidQueue::HealthServer.new(host: @host, port: @port, logger: Logger.new(IO::NULL))
+    @server.start
+    wait_for_server
+  end
+
+  def teardown
+    @server.stop if defined?(@server)
+  end
+
+  def test_health_endpoint_returns_ok
+    response = http_get("/health")
+    assert_equal "200", response.code
+    assert_equal "OK", response.body
+  end
+
+  def test_root_endpoint_returns_ok
+    response = http_get("/")
+    assert_equal "200", response.code
+    assert_equal "OK", response.body
+  end
+
+  def test_unknown_path_returns_not_found
+    response = http_get("/unknown")
+    assert_equal "404", response.code
+    assert_equal "Not Found", response.body
+  end
+
+  def test_stop_stops_server
+    assert @server.running?, "server should be running before stop"
+    @server.stop
+    refute @server.running?, "server should not be running after stop"
+  ensure
+    # Avoid double-stop in teardown if we stopped here
+    @server = SolidQueue::HealthServer.new(host: @host, port: @port, logger: Logger.new(IO::NULL))
+  end
+
+  private
+    def http_get(path)
+      Net::HTTP.start(@host, @port) do |http|
+        http.get(path)
+      end
+    end
+
+    def wait_for_server
+      # Try to connect for up to 1 second
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 1.0
+      begin
+        Net::HTTP.start(@host, @port) { |http| http.head("/") }
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+        raise if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+        sleep 0.05
+        retry
+      end
+    end
+
+    def available_port(host)
+      tcp = TCPServer.new(host, 0)
+      port = tcp.addr[1]
+      tcp.close
+      port
+    end
+end