rails_health_checks 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1ee34c7b5d51ecbfbd7f1f8571daad21f2aea68d68b6ae3abb2013692e4d25b
-  data.tar.gz: 067bba6faa5b8276e1d7e190e5ddeaac050cbf218d8093b00ef865492c640560
+  metadata.gz: 934bfd1962ca10009ba6925f81cbf57f09d8d63ab017a6452296bfb32994352b
+  data.tar.gz: 7ba0cfd783e433b26de67d2f9a2dc00a13e341584c88b1559c5f08e1f237187c
 SHA512:
-  metadata.gz: 7b224e9749a4cecbe92353f278f6d162ee8cca979301754d887f97d76bb004b4ef8305a2cc93aa2ecb7aff21cb7f3bf1e4381daa1ca8f17a32841c19019f14de
-  data.tar.gz: 5c514cdf7dff0471562ad1b4fc549348ea49b2ee1b816fdb730962e9eb3688b94a4750185f06d7cf16102ce00eea326a58be599edcea05b34c6998e511ce0fca
+  metadata.gz: 2e52cb1373a3a8c26bd7a01ceefa6a32dedfb5c06421d754d94150a56349349b3ef467e529e696e9a74efd2449b7f8078bfff5b1a3cf9f2915786e8b16468d87
+  data.tar.gz: 9c1dbc7ea623885abc7cf39acbdc63741fffb25698c93d3beddc501f598783956ede451c60456b8ba1e54bc54c1b725fb70a2a2edc727e6836081d8ff93587fc

data/README.md

@@ -22,6 +22,7 @@ A Rails engine that adds production-grade health check endpoints to any Rails ap
 ## Table of Contents
 
 - [Installation](#installation)
+- [Rack Applications](#rack-applications)
 - [Endpoints](#endpoints)
 - [Configuration](#configuration)
   - [Configuration Reference](#configuration-reference)
@@ -66,6 +67,111 @@ mount RailsHealthChecks::Engine => "/health"
 
 ---
 
+## Rack Applications
+
+`RailsHealthChecks::Rack::App` is a mountable Rack app that exposes the same endpoints without requiring ActionDispatch or Rails routing. It is opt-in — the Rails engine is unaffected.
+
+### Setup
+
+Add to your Gemfile (the gem already lists `rails >= 8.0` as a dependency, so `activesupport` and `concurrent-ruby` are available):
+
+```ruby
+gem "rails_health_checks"
+```
+
+Require and mount the Rack app alongside your existing app:
+
+```ruby
+# config.ru
+require "rails_health_checks"
+require "rails_health_checks/rack/app"
+
+RailsHealthChecks.configure do |config|
+  config.checks = [:disk, :memory, :redis]
+  config.redis_url = ENV["REDIS_URL"]
+end
+
+map "/health" do
+  run RailsHealthChecks::Rack::App
+end
+
+run MyApp
+```
+
+#### Sinatra
+
+```ruby
+require "rails_health_checks/rack/app"
+
+class MyApp < Sinatra::Base
+  use Rack::URLMap, "/health" => RailsHealthChecks::Rack::App
+end
+```
+
+#### Roda
+
+```ruby
+require "rails_health_checks/rack/app"
+
+class MyApp < Roda
+  plugin :multi_run
+  run "/health", RailsHealthChecks::Rack::App
+end
+```
+
+### Available endpoints
+
+The routes are identical to the Rails engine, relative to the mount point:
+
+| Endpoint | Format | Use case |
+|----------|--------|----------|
+| `GET/HEAD /` | JSON | Health status |
+| `GET/HEAD /live` | Plain text | Liveness probe |
+| `GET /metrics` | Prometheus text | Prometheus scraping |
+| `GET /:group` | JSON | Scoped check group |
+
+### Framework-agnostic vs Rails-coupled checks
+
+Checks that depend on Rails internals require those libraries to be present in the stack. Checks that use only stdlib or standalone gems work in any Rack context:
+
+| Check | Works without Rails? |
+|-------|---------------------|
+| `:disk` | Yes |
+| `:memory` | Yes |
+| `:http` | Yes |
+| `:redis` | Yes (requires `redis` gem) |
+| `:smtp` | Yes (reads `ActionMailer` config if available, otherwise requires `config.smtp_address`) |
+| `:database` | Requires ActiveRecord |
+| `:cache` | Requires `Rails.cache` |
+| `:sidekiq` | Requires Sidekiq |
+| `:solid_queue` | Requires SolidQueue |
+| `:good_job` | Requires GoodJob |
+| `:resque` | Requires Resque |
+
+### Per-environment toggling in Rack
+
+`config.disable :check, in: :env` compares against `Rails.env` in a Rails app. In a non-Rails Rack app it reads `ENV["RACK_ENV"]` instead (defaulting to `"production"` if unset):
+
+```ruby
+config.disable :disk, in: :test   # compares RACK_ENV when Rails is not defined
+```
+
+### Authentication in Rack
+
+All three authentication strategies work identically. When using the custom block strategy, the argument is a `Rack::Request` instead of `ActionDispatch::Request`:
+
+```ruby
+RailsHealthChecks.configure do |config|
+  config.authenticate { |request| request.env["HTTP_X_INTERNAL"] == "true" }
+end
+```
+
+Token and IP allowlist strategies are unchanged.
+
+[↑ Back to top](#table-of-contents)
+
+---
+
 ## Endpoints
 
 | Endpoint | Format | Use case |
@@ -274,7 +380,7 @@ RailsHealthChecks.configure do |config|
 end
 ```
 
-The block receives the `ActionDispatch::Request` object and must return a truthy value to allow access.
+The block receives the request object and must return a truthy value to allow access. In a Rails app this is `ActionDispatch::Request`; in the Rack app it is `Rack::Request`.
 
 [↑ Back to top](#table-of-contents)
 

data/lib/rails_health_checks/check_registry.rb

@@ -46,7 +46,7 @@ module RailsHealthChecks
 
     def self.run(checks, timeout:)
       results = {}
-      ActiveSupport::Notifications.instrument("health_check.rails_health_checks") do |payload|
+      instrument do |payload|
         futures = checks.transform_values do |check|
           t = check.timeout || timeout
           Concurrent::Future.execute { run_check(check, timeout: t) }
@@ -55,14 +55,26 @@ module RailsHealthChecks
           t = check.timeout || timeout
           results[name] = futures[name].value(t + 1) || mark_critical(check, "timed out")
         end
-        payload[:status] = overall_status(results)
-        payload[:checks] = results.transform_values do |c|
-          { status: c.status, message: c.message, latency_ms: c.latency_ms }.compact
+        if payload
+          payload[:status] = overall_status(results)
+          payload[:checks] = results.transform_values do |c|
+            { status: c.status, message: c.message, latency_ms: c.latency_ms }.compact
+          end
         end
       end
       results
     end
 
+    def self.instrument(&block)
+      if defined?(ActiveSupport::Notifications)
+        ActiveSupport::Notifications.instrument("health_check.rails_health_checks", &block)
+      else
+        # :nocov:
+        yield nil
+        # :nocov:
+      end
+    end
+
     def self.run_check(check, timeout:)
       Timeout.timeout(timeout) { check.call }
       check
@@ -86,6 +98,6 @@ module RailsHealthChecks
       end
     end
 
-    private_class_method :run_check, :mark_critical, :overall_status
+    private_class_method :run_check, :mark_critical, :overall_status, :instrument
   end
 end

data/lib/rails_health_checks/configuration.rb

@@ -42,7 +42,8 @@ module RailsHealthChecks
     end
 
     def checks
-      disabled = @disabled_checks.filter_map { |name, envs| name if envs.include?(Rails.env.to_s) }
+      current_env = defined?(Rails) ? Rails.env.to_s : ENV.fetch("RACK_ENV", "production")
+      disabled = @disabled_checks.filter_map { |name, envs| name if envs.include?(current_env) }
       @checks - disabled
     end
 

data/lib/rails_health_checks/rack/app.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require "json"
+require "rack"
+
+module RailsHealthChecks
+  module Rack
+    # Mountable Rack app exposing the same endpoints as the Rails engine.
+    # Mount in config.ru:
+    #
+    #   require "rails_health_checks/rack/app"
+    #   map "/health" { run RailsHealthChecks::Rack::App }
+    #
+    # Or in Sinatra/Roda via their mount helpers.
+    #
+    # Available routes (relative to mount point):
+    #   GET/HEAD /          → JSON health (same shape as Rails engine)
+    #   GET/HEAD /live      → plain-text liveness probe
+    #   GET      /metrics   → Prometheus text format
+    #   GET      /:group    → scoped group JSON
+    class App
+      def self.call(env)
+        new(env).call
+      end
+
+      def initialize(env)
+        @env = env
+        @request = ::Rack::Request.new(env)
+      end
+
+      def call
+        return unauthorized unless authorized?
+
+        response = dispatch
+        @request.head? ? [response[0], response[1], []] : response
+      end
+
+      def dispatch
+        path   = @request.path_info.delete_suffix("/")
+        method = @request.request_method
+
+        case [method, path]
+        when ["GET", ""], ["HEAD", ""]
+          health_response
+        when ["GET", "/live"], ["HEAD", "/live"]
+          live_response
+        when ["GET", "/metrics"]
+          metrics_response
+        else
+          if %w[GET HEAD].include?(method) && (m = path.match(%r{\A/([^/]+)\z}))
+            group_response(m[1])
+          else
+            not_found
+          end
+        end
+      end
+
+      private
+
+      def run_checks(check_names)
+        config = RailsHealthChecks.configuration
+        if config.cache_duration
+          cache_key = check_names.map(&:to_s).sort.join(",")
+          RailsHealthChecks.result_cache.fetch(cache_key, ttl: config.cache_duration) do
+            build_and_run(check_names, config)
+          end
+        else
+          build_and_run(check_names, config)
+        end
+      end
+
+      def build_and_run(check_names, config)
+        checks = CheckRegistry.build(check_names)
+        CheckRegistry.run(checks, timeout: config.timeout)
+      end
+
+      def health_response
+        builder = ResponseBuilder.new(run_checks(RailsHealthChecks.configuration.checks))
+        json(builder.http_status == :ok ? 200 : 503, builder.to_json)
+      end
+
+      def live_response
+        builder = ResponseBuilder.new(run_checks(RailsHealthChecks.configuration.checks))
+        if builder.overall_status == "ok"
+          plain(200, "OK")
+        else
+          plain(503, "Service Unavailable")
+        end
+      end
+
+      def metrics_response
+        results = run_checks(RailsHealthChecks.configuration.checks)
+        [200, { "Content-Type" => "text/plain; version=0.0.4" }, [PrometheusFormatter.new(results).to_text]]
+      end
+
+      def group_response(id)
+        group_name  = id.to_sym
+        check_names = RailsHealthChecks.configuration.groups[group_name]
+        return not_found("Group '#{group_name}' not found") unless check_names
+
+        builder = ResponseBuilder.new(run_checks(check_names))
+        json(builder.http_status == :ok ? 200 : 503, builder.to_json)
+      end
+
+      def authorized?
+        config = RailsHealthChecks.configuration
+        return true unless config.authenticate_block || config.token || config.allowed_ips
+
+        if config.authenticate_block
+          config.authenticate_block.call(@request)
+        elsif config.token
+          @env["HTTP_AUTHORIZATION"] == "Bearer #{config.token}"
+        elsif config.allowed_ips
+          ip_allowed?(config.allowed_ips)
+        end
+      end
+
+      def ip_allowed?(allowed_ips)
+        client_ip = IPAddr.new(@request.ip)
+        allowed_ips.any? { |entry| IPAddr.new(entry).include?(client_ip) }
+      rescue IPAddr::InvalidAddressError
+        false
+      end
+
+      def json(status, body)
+        [status, { "Content-Type" => "application/json" }, [body]]
+      end
+
+      def plain(status, body)
+        [status, { "Content-Type" => "text/plain" }, [body]]
+      end
+
+      def unauthorized
+        json(401, { error: "Unauthorized" }.to_json)
+      end
+
+      def not_found(message = "Not found")
+        json(404, { error: message }.to_json)
+      end
+    end
+  end
+end

data/lib/rails_health_checks/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsHealthChecks
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/lib/rails_health_checks.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "rails_health_checks/version"
-require "rails_health_checks/engine"
+require "rails_health_checks/engine" if defined?(Rails)
 require "rails_health_checks/configuration"
 require "rails_health_checks/authentication"
 require "rails_health_checks/check"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_health_checks
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Chuck Smith
@@ -15,14 +15,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: A Rails engine that adds structured, pluggable health check endpoints
   to any Rails app. Includes 11 built-in checks (database, cache, Redis, SMTP, Sidekiq,
   SolidQueue, GoodJob, Resque, disk, memory, HTTP), parallel execution via Concurrent::Future,
@@ -67,6 +81,7 @@ files:
 - lib/rails_health_checks/configuration.rb
 - lib/rails_health_checks/engine.rb
 - lib/rails_health_checks/prometheus_formatter.rb
+- lib/rails_health_checks/rack/app.rb
 - lib/rails_health_checks/response_builder.rb
 - lib/rails_health_checks/result_cache.rb
 - lib/rails_health_checks/version.rb