standard_health 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 298b48147224460e942fb5dd9440596ef128f0967dc7212a507756b9b45ae1b5
+  data.tar.gz: 5008923ddf09d5637f9e6c07b95bf9073b15d0e79b2d0e00646170478e5d7aee
+SHA512:
+  metadata.gz: 61f79addc2cba3dc84019036dd38b0917b5c812193b6b8af551b4efdd8578f93499a8efaed5f95b38efa07d71bf5d3bfe19495ff7f54eea145895169289aa7e5
+  data.tar.gz: ff348b35a931bed97044118e15b275ac1daed5fae93929c1f2976bc1db1947dbbeb8a05fe8029bc277311e6174e73e8be94c3afc060c880282a1fa1906406d63

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-04-28
+
+### Added
+
+- Initial release of `standard_health` — a mountable Rails engine providing `/alive`, `/ready`, and `/diagnostics/env` endpoints.
+- `StandardHealth.configure` block with `register_check`, `parent_controller`, and `env_spec` accessors.
+- `StandardHealth::EnvSpec` DSL for declaring required and recommended environment variables, with optional per-mode applicability via `in:`.
+- Built-in checks: `Checks::ActiveRecord`, `Checks::SolidQueue`, `Checks::SolidCache`.
+- `StandardHealth::Aggregator` rolls registered checks into `:ok` / `:degraded` / `:unavailable` overall status.
+- `StandardHealth::Check` base class with a `with_timing` helper for subclasses.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2026 Jaryl Sim
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,144 @@
+# StandardHealth
+
+A drop-in health check and environment-spec engine for Rails 8 host apps.
+
+Mount it once and you get:
+
+- `GET /health/alive` — liveness probe (always 200 if Rails is up)
+- `GET /health/ready` — readiness probe; runs every registered check and rolls them up into an overall status
+- `GET /health/diagnostics/env` — audits the host app's `ENV` against a declarative spec
+
+Built-in checks cover ActiveRecord, SolidQueue, and SolidCache. Host apps can register additional checks via the configuration block.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "standard_health"
+```
+
+Then `bundle install`.
+
+## Mounting
+
+In `config/routes.rb`:
+
+```ruby
+mount StandardHealth::Engine => "/health"
+```
+
+This wires up:
+
+- `GET /health/alive`
+- `GET /health/ready`
+- `GET /health/diagnostics/env`
+
+## Configuration
+
+Create `config/initializers/standard_health.rb`:
+
+```ruby
+StandardHealth.configure do |c|
+  # Controllers under StandardHealth inherit from this class. Use a host
+  # app controller to apply auth before_actions to every endpoint.
+  c.parent_controller = "ApplicationController"
+
+  # Register checks. The first argument is a short name surfaced in JSON;
+  # `critical: true` means a failure flips overall status to :unavailable.
+  c.register_check :database, StandardHealth::Checks::ActiveRecord, critical: true
+  c.register_check :solid_queue, StandardHealth::Checks::SolidQueue, critical: true
+  c.register_check :solid_cache, StandardHealth::Checks::SolidCache, critical: false
+
+  # Declare the env vars your app expects.
+  c.env_spec = StandardHealth::EnvSpec.define do
+    required :SECRET_KEY_BASE
+    required :APP_ENVIRONMENT, in: %w[staging production]
+    required :DATABASE_URL,    in: %w[production]
+    recommended :SENTRY_DSN, description: "Error tracking DSN"
+  end
+end
+```
+
+## EnvSpec
+
+The DSL has two declarations:
+
+- `required :NAME` — missing value reports `status: :missing`
+- `recommended :NAME` — missing value reports `status: :should_set`
+
+Both accept:
+
+- `in: %w[staging production]` — restricts the entry to those `APP_ENVIRONMENT` values; ignored otherwise
+- `description: "..."` — surfaced verbatim in the audit JSON
+
+Audit output (one row per applicable entry):
+
+```json
+{
+  "name": "SECRET_KEY_BASE",
+  "level": "required",
+  "status": "ok",
+  "mode": "production"
+}
+```
+
+Possible `status` values are `ok`, `missing` (required + absent), and `should_set` (recommended + absent).
+
+## Custom checks
+
+Inherit from `StandardHealth::Check` and implement `#run`:
+
+```ruby
+class RedisCheck < StandardHealth::Check
+  def run
+    with_timing { Redis.current.ping }
+  end
+end
+
+StandardHealth.configure do |c|
+  c.register_check :redis, RedisCheck, critical: false
+end
+```
+
+`with_timing` captures `latency_ms` on success and converts any `StandardError` into `{ status: :fail, error: <message> }`.
+
+## Auth
+
+`/alive` and `/ready` are typically left open for orchestrator probes. `/diagnostics/env` enumerates which env vars are missing — that's potentially sensitive, so the host app is responsible for protecting it.
+
+The recommended pattern is to point `parent_controller` at a host app controller that enforces auth:
+
+```ruby
+# app/controllers/internal_health_controller.rb
+class InternalHealthController < ActionController::API
+  http_basic_authenticate_with(
+    name: ENV.fetch("HEALTH_USER"),
+    password: ENV.fetch("HEALTH_PASS"),
+    only: :env # only protect diagnostics
+  )
+end
+
+# config/initializers/standard_health.rb
+StandardHealth.configure do |c|
+  c.parent_controller = "InternalHealthController"
+end
+```
+
+For a more granular setup, mount the engine inside an authenticated route block in your host app's `routes.rb`.
+
+## Status semantics
+
+`/ready` returns:
+
+| Overall status | HTTP code | Meaning |
+|---|---|---|
+| `ok` | 200 | All checks passed |
+| `degraded` | 200 | A non-critical check failed |
+| `unavailable` | 503 | A critical check failed |
+
+The orchestrator should pull the instance out of rotation only on 503; degraded means "still serving, page someone."
+
+## License
+
+MIT.

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake" if File.exist?(APP_RAKEFILE)
+
+require "bundler/gem_tasks"
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+  # rspec not available — skip
+end

data/app/controllers/standard_health/application_controller.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module StandardHealth
+  # Base controller for all StandardHealth endpoints.
+  #
+  # Lazily inherits from `StandardHealth.config.parent_controller` so host
+  # apps can wire their own auth/rate-limiting/before_actions in once and
+  # have them apply to /alive, /ready, and /diagnostics/env. The default
+  # is `ActionController::API` so the engine works in API-only host apps
+  # without configuration.
+  #
+  # Resolution happens at the moment this class is first referenced, which
+  # is request time — by then the host app's controllers are loaded and
+  # the constant resolves cleanly. Caching the resolved class on the
+  # singleton avoids re-running `constantize` per request.
+  def self.parent_controller
+    @parent_controller ||= config.parent_controller.constantize
+  end
+
+  # Allow tests/host apps to bust the cached parent controller (e.g. when
+  # toggling config between examples).
+  def self.reset_parent_controller!
+    @parent_controller = nil
+  end
+
+  class ApplicationController < parent_controller
+  end
+end

data/app/controllers/standard_health/diagnostics_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module StandardHealth
+  # Diagnostics endpoints. Output here is potentially sensitive (it
+  # enumerates which env vars are missing), so host apps are responsible
+  # for wrapping these routes with authentication via `parent_controller`
+  # — typically a basic-auth `before_action` on `ApplicationController`.
+  class DiagnosticsController < ApplicationController
+    # Audits the configured EnvSpec against the current process ENV and
+    # returns the result as JSON. When no EnvSpec is configured the
+    # endpoint returns an empty audit rather than a 404 so callers don't
+    # have to special-case "feature not enabled".
+    def env
+      spec = StandardHealth.config.env_spec
+      mode = ENV["APP_ENVIRONMENT"].to_s
+
+      audit = spec ? spec.audit(ENV.to_h, mode: mode) : []
+
+      render json: {
+        mode: mode,
+        audit: audit,
+        generated_at: Time.now.utc.iso8601
+      }
+    end
+  end
+end

data/app/controllers/standard_health/health_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module StandardHealth
+  class HealthController < ApplicationController
+    # Liveness probe. Returns 200 unconditionally — its only job is to
+    # confirm the Rails process is up and routing requests. Anything
+    # heavier belongs in /ready.
+    def alive
+      head :ok
+    end
+
+    # Readiness probe. Runs every registered check and returns:
+    #   200 if the rolled-up status is :ok or :degraded
+    #   503 if any critical check failed (:unavailable)
+    def ready
+      result = StandardHealth::Aggregator.call
+      http_status = result[:status] == :unavailable ? :service_unavailable : :ok
+      render json: result, status: http_status
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+StandardHealth::Engine.routes.draw do
+  get "/alive", to: "health#alive"
+  get "/ready", to: "health#ready"
+
+  namespace :diagnostics do
+    get :env
+  end
+end

data/lib/standard_health/aggregator.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module StandardHealth
+  # Runs all registered checks and rolls them up into a single status.
+  #
+  # Status semantics:
+  #   :ok           — every check returned :ok
+  #   :degraded     — at least one non-critical check failed
+  #   :unavailable  — at least one critical check failed
+  #
+  # The aggregator never raises. Each check is invoked through
+  # `safe_run` which catches `StandardError` so a buggy custom check
+  # cannot take down /ready.
+  class Aggregator
+    def self.call(checks: StandardHealth.config.checks, now: Time.now.utc)
+      check_rows = checks.map { |reg| safe_run(reg) }
+      {
+        status: overall_status(check_rows),
+        checks: check_rows,
+        generated_at: now.iso8601
+      }
+    end
+
+    def self.safe_run(reg)
+      result = reg.klass.new(name: reg.name, critical: reg.critical).run
+      result.merge(name: reg.name, critical: reg.critical)
+    rescue StandardError => e
+      {
+        name: reg.name,
+        critical: reg.critical,
+        status: :fail,
+        error: e.message
+      }
+    end
+    private_class_method :safe_run
+
+    def self.overall_status(rows)
+      return :ok if rows.empty?
+
+      failures = rows.reject { |r| r[:status] == :ok }
+      return :ok if failures.empty?
+      return :unavailable if failures.any? { |r| r[:critical] }
+
+      :degraded
+    end
+    private_class_method :overall_status
+  end
+end

data/lib/standard_health/check.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module StandardHealth
+  # Base class for health checks.
+  #
+  # Subclasses implement `#run`, returning a hash like:
+  #
+  #   { status: :ok, latency_ms: 3 }
+  #
+  # or
+  #
+  #   { status: :fail, error: "connection refused" }
+  #
+  # The `with_timing` helper wraps a block, captures latency, and converts
+  # any unhandled `StandardError` into a `:fail` row so subclasses don't
+  # have to repeat the pattern.
+  class Check
+    attr_reader :name, :critical
+
+    def initialize(name:, critical: false)
+      @name = name
+      @critical = critical
+    end
+
+    def critical?
+      !!@critical
+    end
+
+    # Subclasses override this. Default implementation reports an
+    # unimplemented check rather than raising, so a misconfigured custom
+    # check degrades gracefully instead of taking down /ready.
+    def run
+      { status: :fail, error: "not implemented" }
+    end
+
+    # Wrap a block: time it, return :ok with latency_ms on success, or
+    # :fail with the error message on any StandardError. Useful for
+    # check implementations that boil down to "run this query, swallow
+    # exceptions, report status".
+    def with_timing
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      yield
+      latency_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
+      { status: :ok, latency_ms: latency_ms }
+    rescue StandardError => e
+      { status: :fail, error: e.message }
+    end
+  end
+end

data/lib/standard_health/checks/active_record.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "standard_health/check"
+
+module StandardHealth
+  module Checks
+    # Verifies the primary database connection by executing `SELECT 1`.
+    # Critical by default — if the database is unreachable, the host app
+    # cannot serve meaningful traffic.
+    class ActiveRecord < Check
+      def initialize(name: :active_record, critical: true)
+        super
+      end
+
+      def run
+        with_timing do
+          ::ActiveRecord::Base.connection.execute("SELECT 1")
+        end
+      end
+    end
+  end
+end

data/lib/standard_health/checks/solid_cache.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "standard_health/check"
+
+module StandardHealth
+  module Checks
+    # Verifies the Rails cache is reachable via a read-only probe.
+    #
+    # We deliberately don't write — a flapping cache shouldn't corrupt host
+    # app cache state. If the read raises (connection refused, decoding
+    # error, etc.), the check fails. Non-critical by default: a degraded
+    # cache shouldn't pull the app out of rotation.
+    class SolidCache < Check
+      PROBE_KEY = "standard_health_probe"
+
+      def initialize(name: :solid_cache, critical: false)
+        super
+      end
+
+      def run
+        with_timing do
+          ::Rails.cache.read(PROBE_KEY)
+        end
+      end
+    end
+  end
+end

data/lib/standard_health/checks/solid_queue.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "standard_health/check"
+
+module StandardHealth
+  module Checks
+    # Verifies the SolidQueue backing store is reachable.
+    #
+    # SolidQueue can be configured to live on a dedicated database connection
+    # (`config.solid_queue.connects_to`). When that's the case we run the
+    # probe against `SolidQueue::Record.connection`. Otherwise we fall back
+    # to the primary AR connection — which is exactly where the queue tables
+    # live in single-DB setups.
+    class SolidQueue < Check
+      def initialize(name: :solid_queue, critical: true)
+        super
+      end
+
+      def run
+        with_timing do
+          connection.execute("SELECT 1")
+        end
+      end
+
+      private
+
+      def connection
+        if defined?(::SolidQueue::Record) && ::SolidQueue::Record.respond_to?(:connection)
+          ::SolidQueue::Record.connection
+        else
+          ::ActiveRecord::Base.connection
+        end
+      end
+    end
+  end
+end

data/lib/standard_health/configuration.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module StandardHealth
+  # Holds engine-wide configuration.
+  #
+  # Host apps configure the engine via:
+  #
+  #   StandardHealth.configure do |c|
+  #     c.parent_controller = "ApplicationController"
+  #     c.register_check :custom, MyCheck, critical: true
+  #     c.env_spec = StandardHealth::EnvSpec.define { ... }
+  #   end
+  class Configuration
+    # A registered health check entry.
+    Registration = Struct.new(:name, :klass, :critical, keyword_init: true) do
+      def critical?
+        !!critical
+      end
+    end
+
+    # Class name of the controller that StandardHealth's controllers should
+    # inherit from. Resolved lazily via `constantize` at request time so the
+    # host app's controller (which may pull in auth concerns) is fully
+    # loaded before we touch it. Defaults to `ActionController::API` so the
+    # engine works in API-only host apps without configuration.
+    attr_accessor :parent_controller
+
+    # An optional `StandardHealth::EnvSpec` instance describing required and
+    # recommended environment variables for the host app. Audited via the
+    # /diagnostics/env endpoint.
+    attr_accessor :env_spec
+
+    def initialize
+      @parent_controller = "ActionController::API"
+      @env_spec = nil
+      @checks = []
+    end
+
+    # Register a health check class.
+    #
+    # @param name [Symbol] short identifier surfaced in /ready output
+    # @param klass [Class] subclass of StandardHealth::Check
+    # @param critical [Boolean] failure flips overall status to :unavailable
+    def register_check(name, klass, critical: false)
+      @checks << Registration.new(name: name.to_sym, klass: klass, critical: critical)
+    end
+
+    # @return [Array<Registration>] frozen view of registered checks
+    def checks
+      @checks.dup
+    end
+
+    # Remove all registered checks. Mainly useful in tests where the host
+    # app and the engine share a process.
+    def reset_checks!
+      @checks = []
+    end
+  end
+end

data/lib/standard_health/engine.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module StandardHealth
+  class Engine < ::Rails::Engine
+    isolate_namespace StandardHealth
+  end
+end

data/lib/standard_health/env_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module StandardHealth
+  # DSL for declaring required and recommended environment variables.
+  #
+  # Example:
+  #
+  #   StandardHealth::EnvSpec.define do
+  #     required :SECRET_KEY_BASE
+  #     required :APP_ENVIRONMENT, in: %w[staging production]
+  #     recommended :SENTRY_DSN, description: "Error tracking DSN"
+  #   end
+  #
+  # Each entry has:
+  #   - `name` (Symbol)
+  #   - `level` (:required | :recommended)
+  #   - `modes` (Array<String>, optional) — when set, the entry only applies
+  #     while `APP_ENVIRONMENT` matches one of these modes. Otherwise it
+  #     applies to every mode.
+  #   - `description` (String, optional) — human-readable hint surfaced
+  #     verbatim by `/diagnostics/env`.
+  class EnvSpec
+    Entry = Struct.new(:name, :level, :modes, :description, keyword_init: true) do
+      # Whether this entry's audit applies under the given runtime mode.
+      # Entries without a `modes:` constraint always apply.
+      def applies_to?(mode)
+        return true if modes.nil? || modes.empty?
+        modes.include?(mode.to_s)
+      end
+    end
+
+    # @return [Array<Entry>]
+    attr_reader :entries
+
+    # Build a spec via the DSL.
+    def self.define(&block)
+      new.tap { |spec| spec.instance_eval(&block) if block }
+    end
+
+    def initialize
+      @entries = []
+    end
+
+    # Declare a required env var.
+    #
+    # @param name [Symbol, String]
+    # @param in [Array<String>, nil] limit applicability to these modes
+    # @param description [String, nil]
+    def required(name, **opts)
+      add(:required, name, **opts)
+    end
+
+    # Declare a recommended env var. A missing value never fails the audit;
+    # it surfaces as `:should_set`.
+    def recommended(name, **opts)
+      add(:recommended, name, **opts)
+    end
+
+    # Run the audit against an env-like hash.
+    #
+    # @param env_hash [Hash{String, Symbol => String}] e.g. ENV.to_h
+    # @param mode [String, Symbol] current APP_ENVIRONMENT value
+    # @return [Array<Hash>] one row per applicable entry, each shaped like:
+    #   { name:, level:, status: :ok | :missing | :should_set, mode: }
+    def audit(env_hash, mode:)
+      mode_str = mode.to_s
+      env = stringify(env_hash)
+
+      @entries.each_with_object([]) do |entry, out|
+        next unless entry.applies_to?(mode_str)
+
+        value = env[entry.name.to_s]
+        status = classify(entry, value)
+
+        row = {
+          name: entry.name,
+          level: entry.level,
+          status: status,
+          mode: mode_str
+        }
+        row[:description] = entry.description if entry.description
+        out << row
+      end
+    end
+
+    private
+
+    def add(level, name, in: nil, description: nil)
+      modes = binding.local_variable_get(:in)
+      @entries << Entry.new(
+        name: name.to_sym,
+        level: level,
+        modes: modes ? Array(modes).map(&:to_s) : nil,
+        description: description
+      )
+    end
+
+    def classify(entry, value)
+      present = !value.nil? && !value.to_s.empty?
+      return :ok if present
+
+      entry.level == :required ? :missing : :should_set
+    end
+
+    def stringify(env_hash)
+      env_hash.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+    end
+  end
+end

data/lib/standard_health/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module StandardHealth
+  VERSION = "0.1.0"
+end

data/lib/standard_health.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "standard_health/version"
+require "standard_health/engine"
+require "standard_health/configuration"
+require "standard_health/env_spec"
+require "standard_health/check"
+require "standard_health/checks/active_record"
+require "standard_health/checks/solid_queue"
+require "standard_health/checks/solid_cache"
+require "standard_health/aggregator"
+
+module StandardHealth
+  class << self
+    # Yields the configuration to a block.
+    #
+    #   StandardHealth.configure do |c|
+    #     c.parent_controller = "ApplicationController"
+    #     c.register_check :db, StandardHealth::Checks::ActiveRecord, critical: true
+    #   end
+    def configure
+      yield config if block_given?
+      config
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    # Mostly useful in tests — wipes the singleton config so each example
+    # gets a clean slate.
+    def reset_config!
+      @config = Configuration.new
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: standard_health
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jaryl Sim
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+description: StandardHealth is a mountable Rails engine providing /alive, /ready,
+  and /diagnostics/env endpoints, with a configuration block for registering custom
+  checks and a DSL for declaring required and recommended environment variables.
+email:
+- code@jaryl.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/standard_health/application_controller.rb
+- app/controllers/standard_health/diagnostics_controller.rb
+- app/controllers/standard_health/health_controller.rb
+- config/routes.rb
+- lib/standard_health.rb
+- lib/standard_health/aggregator.rb
+- lib/standard_health/check.rb
+- lib/standard_health/checks/active_record.rb
+- lib/standard_health/checks/solid_cache.rb
+- lib/standard_health/checks/solid_queue.rb
+- lib/standard_health/configuration.rb
+- lib/standard_health/engine.rb
+- lib/standard_health/env_spec.rb
+- lib/standard_health/version.rb
+homepage: https://github.com/rarebit-one/standard_health
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rarebit-one/standard_health
+  source_code_uri: https://github.com/rarebit-one/standard_health
+  changelog_uri: https://github.com/rarebit-one/standard_health/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/rarebit-one/standard_health/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A drop-in health check and environment-spec engine for Rails 8 host apps.
+test_files: []