standard_health 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5845fe7433611028fb103afb457683b22717a8f1aa79848f425a2cd5d7c9bd7a
-  data.tar.gz: c83d29991ba9b19b2ce234e5ef3cacabf198af323b97809927ef36608c49ba7e
+  metadata.gz: 2c32e1366e2b116f86a8be7780d4717a35b07952402f14e213a2533530c30fe8
+  data.tar.gz: 7c0fe9a0993be6e1ef46adcd95f3ba6c05dc029e7f621557ea314eb0a7062f0e
 SHA512:
-  metadata.gz: eddef6b2df86d0ff116a63793b009f3b3afe81ed3f437fcd5f1fea15be0545ca2a384ea346bae3c12050ffc8f95183af4ee5414a8739ead14910b2bcd0a45ea5
-  data.tar.gz: cb15f56c75ec0464412c16360d788b8f714d73c844a3e7bde8564295e56d2e56bdc63bb9c5987792efd65c8c3158e4e9b0edde991f0ea69e0a8dfecf93c9361f
+  metadata.gz: ad3e4a667c77a923dfa0ab49aa1de21f86923e7a1e30e7f7204c9ebb4c471f284f61c4f1d0a768155345da3fd46f10b7b77216d6feeeb0c9b799bc7f29bc02f7
+  data.tar.gz: '00853d5d4423f12269bf47f67692bcea3c43bc7da5ac9b64ff39fb9f080364131bea90156cc3fd41387d37421cef886695965c66d28fa024c9e3de418b07458b'

data/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.1] - 2026-09-24
+
+### Fixed
+
+- **A check that raises on the aggregate tier is reported to `Rails.error` again.** Before 0.6.0 every host's aggregate controller rescued a raising check and called `Rails.error.report(e, handled: true, ...)`. When the engine took over the tier, the exception was only logged by the Logger notifier, so a buggy aggregate check stopped reaching Sentry (noted in the jumpdrive-web and sidekick-web adoptions). The Aggregator now reports it as handled with context `{ health_check: <name>, tier: "aggregate" }`. Severity follows the readiness Sentry notifier: `:error` for a critical check, `:warning` otherwise. The readiness tier is unchanged. Its failures still reach Sentry through the transition-gated `ready.evaluated` notifier, which keeps a ~6/min probe from flooding the tracker. Checks that return a `:fail` row (every built-in check) are not reported. The report is rescued, so a broken error subscriber cannot 500 the tier.
+
+### Documentation
+
+- The aggregate tier re-runs the `register_check` readiness checks by default (`aggregate_readiness_checks = true`), so a failing critical check (database, Solid Queue) makes `/health` answer **503 `unavailable`**, not only `/ready`.
+- The aggregate body reports `"unavailable"`, never StandardCircuit's `"critical"`. Monitors matching on `"critical"` need updating (as noted in 0.6.0's migration notes).
+- `StandardHealth::DiagnosticsAuthentication` is the request-time gate behind `diagnostics_basic_auth`. The README now notes that a host can include it into its own diagnostics controller, as sidekick-web does. It is not yet a documented, semver-stable extension point.
+
 ## [0.6.0] - 2026-09-24
 
 DX release: absorbs the code every consumer app copy-pasted around the engine.

data/README.md

@@ -109,14 +109,30 @@ end
 | `degraded` | 200 | a non-critical check failed or was skipped, or the circuit roll-up is `:degraded` |
 | `ok` | 200 | otherwise |
 
+**The aggregate tier re-runs your readiness checks by default.** With
+`aggregate_readiness_checks` on (the default), every `register_check`
+registration runs here as well as on `/ready`. A failing critical check, such
+as `:database` or `:solid_queue` from `register_default_checks`, therefore turns
+`/health` into a **503 `unavailable`**, not just `/ready`. Point an uptime
+monitor at `/health` and a database outage pages as a 503. If your aggregate
+tier should only report soft signals (sidekick), set
+`aggregate_readiness_checks = false`.
+
 StandardCircuit's own word `critical` is translated to `unavailable`, so both
-tiers speak one vocabulary. `circuits` is omitted when StandardCircuit isn't
+tiers speak one vocabulary. The aggregate body never says `"critical"`. `circuits` is omitted when StandardCircuit isn't
 loaded (or `aggregate_circuits = false`); if `health_report` raises (circuit
 store down) the tier degrades and reports `circuits_error: { error_class,
 error_code }` instead of 500ing. Check rows are redacted exactly like `/ready`,
 with the same `detail_token` break-glass. `register_aggregate_check` checks
 run **only** here — never on `/ready` — and default to `critical: false`.
 
+A check that **raises** on this tier, rather than returning a `:fail` row, is
+also reported to `Rails.error` as handled (since 0.6.1), with context
+`{ health_check:, tier: "aggregate" }` and severity `:error` for a critical
+check or `:warning` otherwise. That matches what the pre-0.6 host controllers
+did. `/ready` does not do this: its failures reach Sentry through the
+transition-gated `ready.evaluated` notifier.
+
 With `aggregate_endpoint` off (the default) the engine's root route carries a
 per-request constraint that never matches, so a bare `/health` cascades to your
 own route exactly as before. Once on, the engine answers `/health` regardless
@@ -590,6 +606,13 @@ c.diagnostics_basic_auth = {
   nothing.
 - Off by default; independent of `diagnostics_parent_controller` (if you set
   both, the parent's callbacks run first).
+- The request-time gate is the `StandardHealth::DiagnosticsAuthentication`
+  concern, which the engine includes into its own `DiagnosticsController`.
+  sidekick-web also includes it into its own `HealthDiagnosticsController`
+  (an `ActionController::API` subclass) so that controller shares the same
+  gate. That works: the concern is a no-op until `diagnostics_basic_auth` is
+  set, and it adds one `before_action`. It is not yet a documented,
+  semver-stable extension point, so pin your minor version if you depend on it.
 
 **Replace your host code with it.** Delete
 `app/controllers/standard_health_host_controller.rb` and the

data/lib/standard_health/aggregator.rb

@@ -131,10 +131,38 @@ module StandardHealth
         error_class: e.class.name
       }
       emit_check(row, tier)
+      report_raised_check(e, reg, tier)
       row
     end
     private_class_method :safe_run
 
+    # A check that RAISES (rather than returning a :fail row) on a
+    # non-readiness tier goes to `Rails.error` as handled. Before 0.6.0 every
+    # host's aggregate controller did exactly this; moving the tier into the
+    # engine left the exception only in the Logger notifier's line, so a buggy
+    # aggregate check stopped reaching the error tracker.
+    #
+    # Readiness is deliberately excluded: its failures already reach Sentry
+    # through the transition-gated `ready.evaluated` notifier, and reporting
+    # every raise from a ~6/min/instance probe would be exactly the noise that
+    # notifier exists to prevent. Severity mirrors that notifier: a critical
+    # check is an :error (it makes the tier :unavailable), otherwise :warning.
+    def self.report_raised_check(error, reg, tier)
+      return if tier == :ready
+      return unless defined?(::Rails) && ::Rails.respond_to?(:error) && ::Rails.error
+
+      ::Rails.error.report(
+        error,
+        handled: true,
+        severity: reg.critical ? :error : :warning,
+        context: { health_check: reg.name.to_s, tier: tier.to_s }
+      )
+    rescue StandardError
+      # Never-raise: a broken error subscriber must not 500 the tier.
+      nil
+    end
+    private_class_method :report_raised_check
+
     def self.budget_exhausted?(budget, started)
       return false unless budget
 

data/lib/standard_health/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: standard_health
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Jaryl Sim