solid_queue_guard 0.5.0 → 1.0.1

data/README.md

@@ -49,7 +49,7 @@ Checks:
 ✅ Active Job adapter is :solid_queue
 ✅ Queue database configured in database.yml
 ✅ Solid Queue connects_to queue database (pool: 10)
-✅ db/queue_schema.rb exists
+✅ Solid Queue schema tables present
 ❌ Worker threads: 10, queue DB pool: 5
 ⚠️ No workers configured for "mailers" queue
 ⚠️ recurring.yml exists but scheduler may not run
@@ -67,7 +67,7 @@ One command. Actionable output. No Datadog required to get started.
 
 ## What it checks
 
-### v0.1 — Configuration doctor (available now)
+### Configuration doctor
 
 Runs locally, in CI, or pre-deploy. **No extra infrastructure.**
 
@@ -76,15 +76,17 @@ Runs locally, in CI, or pre-deploy. **No extra infrastructure.**
 | **Adapter** | Active Job not set to `:solid_queue` |
 | **Queue database** | Missing `queue` entry in `database.yml` |
 | **connects_to** | Solid Queue pointing at the wrong DB / pool |
-| **Queue schema** | Missing `db/queue_schema.rb` |
+| **Queue schema** | Missing Solid Queue tables in schema files or queue database |
 | **Thread pool** | `threads` > available queue DB connections |
 | **Worker coverage** | Queues with no worker assigned |
 | **Scheduler** | `recurring.yml` tasks without a scheduler |
 | **Env flags** | `SOLID_QUEUE_SKIP_RECURRING=true` in production |
 | **Heartbeats** | Default thresholds that may not fit your deploy |
 | **Puma plugin** | Solid Queue co-located with web in production |
+| **Async supervisor** | `async` mode with thread/pool sizing risks |
+| **Topology** | `queue.yml` worker and pool recommendations |
 
-### v0.2+ — Runtime guards (roadmap)
+### Runtime guards
 
 | Check | Catches |
 | ----- | ------- |
@@ -93,6 +95,7 @@ Runs locally, in CI, or pre-deploy. **No extra infrastructure.**
 | **Dispatcher health** | Scheduled jobs never becoming ready |
 | **Blocked jobs** | Concurrency control silently holding jobs |
 | **Recurring staleness** | Cron tasks that stopped firing |
+| **Puma plugin runtime** | Plugin enabled but no active Solid Queue processes |
 | **HTTP `/health`** | Kamal, ECS, K8s, UptimeRobot integration |
 
 ---
@@ -104,6 +107,7 @@ Runs locally, in CI, or pre-deploy. **No extra infrastructure.**
 ```bash
 bundle add solid_queue_guard
 bin/rails solid_queue_guard:install
+bin/rails generate solid_queue_guard:install:ci   # optional GitHub Actions workflow
 ```
 
 ### Run the doctor
@@ -138,6 +142,12 @@ Perfect for deploy pipelines:
   run: SOLID_QUEUE_GUARD_STRICT=1 bin/rails solid_queue_guard:doctor
 ```
 
+Or generate a workflow:
+
+```bash
+bin/rails generate solid_queue_guard:install:ci
+```
+
 ### HTTP health
 
 ```ruby
@@ -157,10 +167,164 @@ config.health_token = ENV["SOLID_QUEUE_GUARD_TOKEN"]
 # curl -H "X-Solid-Queue-Guard-Token: $TOKEN" ...
 ```
 
+HTTP status policy (for Kamal, ECS, load balancers):
+
+```ruby
+config.degraded_http_status = 207   # or :ok (200), 503, etc.
+config.unhealthy_http_status = 503  # default
+```
+
 Works with **Kamal**, **Heroku**, **Fly.io**, **ECS/Fargate**, **Kubernetes**, **Better Stack**, **UptimeRobot**.
 
 ---
 
+## How to use it
+
+Solid Queue does not show up in Rails `/up`. **solid_queue_guard** gives you three operational surfaces:
+
+| Surface | Command / URL | Best for |
+| ------- | ------------- | -------- |
+| **Doctor** | `bin/rails solid_queue_guard:doctor` | Local pre-deploy, config review |
+| **CI gate** | `SOLID_QUEUE_GUARD_STRICT=1 bin/rails solid_queue_guard:doctor` | Block merges with broken queue config |
+| **HTTP health** | `GET /solid_queue_guard/health` | Production uptime monitors (Kamal, ECS, UptimeRobot) |
+
+**Mission Control** shows what is happening. **solid_queue_guard** warns what is dangerous. Use both.
+
+### Local and pre-deploy
+
+Run before changing `queue.yml`, `database.yml`, or recurring tasks:
+
+```bash
+bin/rails solid_queue_guard:doctor      # config checks (default scope)
+bin/rails solid_queue_guard:report      # config + runtime when the queue DB is available
+```
+
+By default the install generator sets `config.enabled = Rails.env.production?`, so in **development** checks are skipped unless you enable them:
+
+```ruby
+SolidQueueGuard.configure { |c| c.enabled = true }
+```
+
+Or run with production config locally when validating deploy readiness.
+
+### CI pipelines
+
+Validate **configuration** before deploy. Process/runtime checks usually **skip** in CI because there is no `bin/jobs` supervisor on the runner.
+
+```yaml
+- name: Solid Queue production readiness
+  run: SOLID_QUEUE_GUARD_STRICT=1 bin/rails solid_queue_guard:doctor
+```
+
+`STRICT=1` turns warnings into exit code `1`, so the pipeline fails on misconfigured pools, missing worker coverage, or missing schema tables — not only hard failures.
+
+Generate a starter workflow:
+
+```bash
+bin/rails generate solid_queue_guard:install:ci
+```
+
+### Production monitoring
+
+Mount the engine and point your load balancer or Kamal health check at `/solid_queue_guard/health`:
+
+```ruby
+# config/routes.rb
+mount SolidQueueGuard::Engine, at: "/solid_queue_guard"
+```
+
+Runtime checks matter here: queue lag, stale heartbeats, dispatcher health, and process topology reflect **live** Solid Queue state.
+
+Optional hardening:
+
+```ruby
+config.health_token = ENV["SOLID_QUEUE_GUARD_TOKEN"]
+config.health_cache_ttl = 15.seconds
+config.degraded_http_status = 207   # or :ok (200), 503, etc.
+config.notify_with = [:rails_logger, :slack]
+```
+
+### Typical flow
+
+```text
+Developer          CI                    Production
+    │               │                         │
+    │ doctor        │ doctor --strict           │ GET /health (every 30–60s)
+    ▼               ▼                         ▼
+ "pool wrong?"   block bad deploy          alert: worker dead
+ "schema ok?"    before merge              alert: queue lag
+```
+
+---
+
+## Runtime process checks
+
+Runtime checks query the **queue database** (via `SolidQueue::Record`). If `connects_to` is missing or the DB is unreachable, they **skip** — they do not pass silently as healthy.
+
+### `process_topology` — are the expected roles present?
+
+Reads distinct `kind` values from `solid_queue_processes`:
+
+| Kind | Role |
+| ---- | ---- |
+| `Supervisor` | Parent process (`bin/jobs`) |
+| `Worker` | Consumes ready jobs |
+| `Dispatcher` | Moves scheduled jobs to ready |
+| `Scheduler` | Runs recurring tasks |
+
+| Result | Meaning |
+| ------ | ------- |
+| ⚠️ No processes | Nothing registered — supervisor not running |
+| ⚠️ No Worker | Jobs will not be processed |
+| ⚠️ No Dispatcher | Scheduled work may stall (when recurring/scheduled jobs exist) |
+| ✅ Pass | Expected kinds are present |
+
+This check looks at **presence of records**, not heartbeat freshness.
+
+### `stale_process` — are heartbeats fresh?
+
+Finds processes where `last_heartbeat_at` is older than `stale_process_threshold` (default **5 minutes**):
+
+| Result | Meaning |
+| ------ | ------- |
+| ✅ Pass | All processes reported recently |
+| ❌ Fail | One or more workers/dispatchers look dead or stuck |
+
+Use this in production health to catch workers that died after deploy.
+
+### `pidfile` — optional supervisor liveness
+
+When `tmp/pids/solid_queue.pid` (or `SOLID_QUEUE_PIDFILE`) exists, verifies the PID is alive. Often **warns in development** where `bin/jobs` is not running. Disable if you do not use pidfiles:
+
+```ruby
+config.disabled_checks = [:pidfile]
+```
+
+### `puma_plugin_runtime` — Solid Queue inside Puma
+
+When `plugin :solid_queue` is in `config/puma.rb`, verifies active processes with recent heartbeats exist. **Skips** when the Puma plugin is not enabled.
+
+### Queue schema detection
+
+`QueueSchemaCheck` does **not** require `db/queue_schema.rb`. It validates that all tables for your installed **solid_queue** version exist in any of:
+
+- `db/queue_schema.rb`
+- `db/schema.rb`
+- `db/structure.sql`
+- the connected queue database
+
+Apps that keep Solid Queue tables only in `structure.sql` (common in Revelo-style repos) pass correctly.
+
+### Where each check type applies
+
+| Context | Config checks | Process / runtime checks |
+| ------- | ------------- | ------------------------ |
+| Local `doctor` | ✅ Primary value | ⚠️ Partial without `bin/jobs` |
+| CI `--strict` | ✅ Primary value | ⏭️ Usually skip |
+| Production `/health` | ✅ When DB up | ✅ Primary value |
+
+---
+
 ## Configuration
 
 ```ruby
@@ -177,13 +341,46 @@ SolidQueueGuard.configure do |config|
   config.failed_jobs_threshold = 20
   config.stale_process_threshold = 5.minutes
 
-  # config.health_token = ENV["SOLID_QUEUE_GUARD_TOKEN"]  # v0.2
-  # config.notify_with = [:rails_logger, :slack]          # v0.3
+  # Per-check overrides (v0.6+)
+  config.disabled_checks = [:pidfile]
+  config.checks.queue_lag = { threshold: 10.minutes }
+  config.checks.failed_jobs = { threshold: 5, enabled: true }
+
+  # HTTP status policy (v0.8+)
+  # config.degraded_http_status = 207
+  # config.unhealthy_http_status = 503
+
+  # config.health_token = ENV["SOLID_QUEUE_GUARD_TOKEN"]
+  # config.integrate_rails_health = true
+  # config.notify_with = [:rails_logger, :slack, :datadog, :webhook]
+  # config.metrics_backends = [:statsd, :prometheus, :opentelemetry]
 end
 ```
 
 ---
 
+## Public API (v1.0+)
+
+The following surface is **stable** until `2.0` and follows [semantic versioning](https://semver.org/):
+
+| API | Description |
+| --- | ----------- |
+| `SolidQueueGuard.configure` | Block-style configuration |
+| `SolidQueueGuard.config` | Current configuration object |
+| `SolidQueueGuard.enabled?` | Whether checks run |
+| `solid_queue_guard:doctor` | Config readiness report |
+| `solid_queue_guard:health` | Runtime health report |
+| `solid_queue_guard:report` | Full diagnostic report |
+| `solid_queue_guard:install` | Initializer generator |
+| `solid_queue_guard:install:ci` | GitHub Actions workflow generator |
+| `mount SolidQueueGuard::Engine` | HTTP health endpoint |
+
+Configuration attributes, rake tasks, and health JSON shape are public. Internal check classes and registry are `@api private`.
+
+Breaking changes ship only in major versions (`2.0+`). Deprecations warn one minor version ahead.
+
+---
+
 ## solid_queue_guard vs Mission Control
 
 | | [Mission Control — Jobs](https://github.com/rails/mission_control-jobs) | solid_queue_guard |
@@ -192,9 +389,9 @@ end
 | **UI** | Dashboard | CLI + JSON + health endpoint |
 | **Retry / discard** | Yes | No (use Mission Control) |
 | **Config doctor** | No | Yes |
-| **Queue lag alerts** | No | Yes (v0.2) |
+| **Queue lag alerts** | No | Yes |
 | **Pre-deploy checks** | No | Yes |
-| **Recurring job guard** | Manual inspection | Automatic (v0.2) |
+| **Recurring job guard** | Manual inspection | Automatic |
 
 **Use both.** They solve different problems.
 
@@ -202,13 +399,17 @@ end
 
 ## Roadmap
 
-| Version | Ships |
-| ------- | ----- |
+| Version | Ships | Status |
+| ------- | ----- | ------ |
 | **v0.1** | `doctor` — config checks, CI integration, install generator | ✅ Released |
 | **v0.2** | Runtime health, queue lag, dispatcher/blocked jobs, HTTP endpoint | ✅ Released |
 | **v0.3** | Slack, Datadog, webhook notifications | ✅ Released |
 | **v0.4** | StatsD, Prometheus, OpenTelemetry metrics | ✅ Released |
 | **v0.5** | Auto-recommendations for `queue.yml` topology | ✅ Released |
+| **v0.6** | Per-check configuration (`disabled_checks`, `config.checks`) | ✅ Released |
+| **v0.7** | Puma plugin runtime check, async supervisor awareness | ✅ Released |
+| **v0.8** | HTTP status policy, `install:ci` generator | ✅ Released |
+| **v1.0** | Stable public API, strict semver | ✅ Released |
 
 ---
 
@@ -216,8 +417,9 @@ end
 
 | Gem version | Ruby | Rails |
 | ----------- | ---- | ----- |
-| 0.1.x       | 3.1+ | 7.1, 7.2, 8.0 |
+| 1.0.x       | 3.1+ | 7.1, 7.2, 8.0 |
 | 0.5.x       | 3.1+ | 7.1, 7.2, 8.0 |
+| 0.1.x       | 3.1+ | 7.1, 7.2, 8.0 |
 
 ## Requirements
 
@@ -240,6 +442,8 @@ bundle exec appraisal install
 bundle exec appraisal rake test
 ```
 
+Release a new version by pushing a `v*` tag after CI passes (Trusted Publishing on RubyGems).
+
 ---
 
 ## Contributing

data/app/controllers/solid_queue_guard/health_controller.rb

@@ -24,10 +24,7 @@ module SolidQueueGuard
     end
 
     def http_status_for(status)
-      case status.to_s
-      when 'unhealthy' then :service_unavailable
-      else :ok
-      end
+      HttpStatusPolicy.for_report_status(status)
     end
   end
 end

data/lib/generators/solid_queue_guard/install/USAGE.ci

@@ -0,0 +1,9 @@
+Description:
+    Adds a GitHub Actions workflow that runs `solid_queue_guard:doctor` with strict mode.
+
+Example:
+    bin/rails generate solid_queue_guard:install:ci
+
+    This will create:
+
+        .github/workflows/solid_queue_guard.yml

data/lib/generators/solid_queue_guard/install/ci_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module SolidQueueGuard
+  module Generators
+    module Install
+      class CiGenerator < Rails::Generators::Base
+        source_root File.expand_path('templates', __dir__)
+
+        desc 'Adds a GitHub Actions workflow that runs solid_queue_guard:doctor in CI'
+
+        def copy_workflow
+          template 'solid_queue_guard.yml', '.github/workflows/solid_queue_guard.yml'
+        end
+      end
+    end
+  end
+end

data/lib/generators/solid_queue_guard/install/templates/solid_queue_guard.rb

@@ -14,6 +14,12 @@ SolidQueueGuard.configure do |config|
   config.health_cache_ttl = 15.seconds
   config.scheduled_backlog_threshold = 100
 
+  # config.disabled_checks = [:pidfile]
+  # config.checks.queue_lag = { threshold: 10.minutes }
+  # config.checks.failed_jobs = { threshold: 5, enabled: true }
+  # config.degraded_http_status = 207
+  # config.unhealthy_http_status = 503
+
   # config.health_token = ENV["SOLID_QUEUE_GUARD_TOKEN"]
   # config.integrate_rails_health = true
   # config.notify_with = [:rails_logger, :slack, :datadog, :webhook]

data/lib/generators/solid_queue_guard/install/templates/solid_queue_guard.yml

@@ -0,0 +1,25 @@
+name: Solid Queue Guard
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  doctor:
+    name: Solid Queue production readiness
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: .ruby-version
+          bundler-cache: true
+
+      - name: Prepare test database
+        run: bin/rails db:test:prepare
+
+      - name: Run Solid Queue Guard doctor
+        run: SOLID_QUEUE_GUARD_STRICT=1 bin/rails solid_queue_guard:doctor

data/lib/solid_queue_guard/checks/base.rb

@@ -8,6 +8,10 @@ module SolidQueueGuard
         new(**options).call
       end
 
+      def self.check_id
+        name.demodulize.underscore.delete_suffix('_check')
+      end
+
       def initialize(**options)
         @options = options
       end
@@ -47,6 +51,18 @@ module SolidQueueGuard
       def solid_queue_configuration
         @solid_queue_configuration ||= SolidQueue::Configuration.new
       end
+
+      def check_id
+        self.class.check_id
+      end
+
+      def guard_config
+        SolidQueueGuard.config
+      end
+
+      def check_setting(key, default = nil)
+        guard_config.check_setting(check_id, key, default)
+      end
     end
   end
 end

data/lib/solid_queue_guard/checks/config/async_supervisor_config_check.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SolidQueueGuard
+  module Checks
+    module Config
+      class AsyncSupervisorConfigCheck < Base
+        def call
+          if PumaPluginSupport.async_supervisor_mode?
+            warn(
+              check_id,
+              'Solid Queue supervisor is running in async mode',
+              suggestion: [
+                'Review thread and database pool sizing;',
+                'the processes option in queue.yml is ignored in async mode'
+              ].join(' '),
+              metadata: { supervisor_mode: 'async' }
+            )
+          else
+            pass(check_id, 'Solid Queue supervisor is running in fork mode')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solid_queue_guard/checks/config/puma_colocated_check.rb

@@ -4,27 +4,21 @@ module SolidQueueGuard
   module Checks
     module Config
       class PumaColocatedCheck < Base
-        PUMA_PLUGIN_PATTERN = /plugin\s+:?solid_queue/
-
         def call
-          puma_config = rails_root.join('config/puma.rb')
-
-          return pass('puma_colocated', 'No config/puma.rb found') unless puma_config.exist?
-
-          content = puma_config.read
+          return pass(check_id, 'No config/puma.rb found') unless PumaPluginSupport.puma_config_path.exist?
 
-          if content.match?(PUMA_PLUGIN_PATTERN)
+          if PumaPluginSupport.puma_plugin_enabled?
             if Rails.env.production?
               warn(
-                'puma_colocated',
+                check_id,
                 'Solid Queue Puma plugin is enabled in production',
                 suggestion: 'Run Solid Queue in a dedicated job process for better isolation and memory management'
               )
             else
-              pass('puma_colocated', 'Solid Queue Puma plugin detected (non-production environment)')
+              pass(check_id, 'Solid Queue Puma plugin detected (non-production environment)')
             end
           else
-            pass('puma_colocated', 'Solid Queue is not co-located with Puma')
+            pass(check_id, 'Solid Queue is not co-located with Puma')
           end
         end
       end

data/lib/solid_queue_guard/checks/config/queue_schema_check.rb

@@ -5,18 +5,91 @@ module SolidQueueGuard
     module Config
       class QueueSchemaCheck < Base
         def call
-          schema_path = rails_root.join('db/queue_schema.rb')
+          evaluation = evaluate_schema
 
-          if schema_path.exist?
-            pass('queue_schema', 'db/queue_schema.rb exists')
-          else
+          case evaluation[:status]
+          when :pass
+            pass(check_id, evaluation[:message], metadata: evaluation[:metadata])
+          when :warn
             warn(
-              'queue_schema',
-              'db/queue_schema.rb not found',
-              suggestion: 'Run bin/rails solid_queue:install to generate the queue schema'
+              check_id,
+              evaluation[:message],
+              suggestion: evaluation[:suggestion],
+              metadata: evaluation[:metadata]
+            )
+          else
+            failure(
+              check_id,
+              evaluation[:message],
+              suggestion: evaluation[:suggestion],
+              metadata: evaluation[:metadata]
             )
           end
         end
+
+        private
+
+        def evaluate_schema
+          required = Schema::SolidQueueTables.required_tables
+          detection = Schema::SolidQueueTables.detected_tables(rails_root: rails_root)
+          missing = required - detection[:tables]
+          metadata = schema_metadata(detection, missing: missing)
+
+          return pass_evaluation(detection, required.size, metadata) if missing.empty?
+          return partial_evaluation(missing, metadata) if detection[:tables].any?
+
+          empty_evaluation(metadata)
+        end
+
+        def pass_evaluation(detection, table_count, metadata)
+          {
+            status: :pass,
+            message: success_message(detection, table_count),
+            metadata: metadata
+          }
+        end
+
+        def partial_evaluation(missing, metadata)
+          {
+            status: :warn,
+            message: "Missing Solid Queue tables: #{missing.join(', ')}",
+            suggestion: 'Run bin/rails solid_queue:install or migrate the queue database',
+            metadata: metadata
+          }
+        end
+
+        def empty_evaluation(metadata)
+          {
+            status: :fail,
+            message: [
+              'No Solid Queue schema tables found in',
+              'db/queue_schema.rb, db/schema.rb, db/structure.sql, or the queue database'
+            ].join(' '),
+            suggestion: 'Run bin/rails solid_queue:install and migrate the queue database',
+            metadata: metadata
+          }
+        end
+
+        def success_message(detection, table_count)
+          sources = source_descriptions(detection)
+          "Solid Queue schema complete (#{table_count}/#{table_count} tables) in #{sources.join(', ')}"
+        end
+
+        def source_descriptions(detection)
+          sources = detection[:file_tables].keys
+          sources << 'queue database' if detection[:database_tables].any?
+          sources.presence || ['schema files']
+        end
+
+        def schema_metadata(detection, missing:)
+          {
+            required_tables: Schema::SolidQueueTables.required_tables,
+            detected_tables: detection[:tables],
+            missing_tables: missing,
+            schema_sources: detection[:file_tables],
+            database_tables: detection[:database_tables]
+          }
+        end
       end
     end
   end

data/lib/solid_queue_guard/checks/registry.rb

@@ -15,7 +15,8 @@ module SolidQueueGuard
         Config::EnvFlagsCheck,
         Config::ProcessHeartbeatConfigCheck,
         Config::PumaColocatedCheck,
-        Config::TopologyRecommendationCheck
+        Config::TopologyRecommendationCheck,
+        Config::AsyncSupervisorConfigCheck
       ].freeze
 
       RUNTIME_CHECKS = [
@@ -30,10 +31,15 @@ module SolidQueueGuard
         Runtime::RecurringStaleCheck,
         Runtime::PausedQueueLagCheck,
         Runtime::PidfileCheck,
-        Runtime::FinishedJobsGrowthCheck
+        Runtime::FinishedJobsGrowthCheck,
+        Runtime::PumaPluginRuntimeCheck
       ].freeze
 
       class << self
+        def check_id_for(check_class)
+          check_class.check_id
+        end
+
         def for(scope)
           case scope.to_sym
           when :config then CONFIG_CHECKS

data/lib/solid_queue_guard/checks/runtime/database_support.rb

@@ -28,8 +28,11 @@ module SolidQueueGuard
         end
 
         def lag_threshold_for(queue_name)
-          thresholds = config.queue_lag_thresholds
-          thresholds[queue_name.to_sym] || thresholds[queue_name] || thresholds[:default]
+          thresholds = config.check_setting(:queue_lag, :thresholds, config.queue_lag_thresholds)
+          per_queue = thresholds[queue_name.to_sym] || thresholds[queue_name]
+          return per_queue if per_queue
+
+          config.check_setting(:queue_lag, :threshold, thresholds[:default])
         end
       end
     end

data/lib/solid_queue_guard/checks/runtime/dispatcher_check.rb

@@ -9,16 +9,18 @@ module SolidQueueGuard
             dispatchers = SolidQueue::Process.where(kind: 'Dispatcher')
             due_count = SolidQueue::ScheduledExecution.due.count
 
+            threshold = config.check_setting(:scheduled_backlog, :threshold, config.scheduled_backlog_threshold)
+
             if dispatchers.none? && due_count.positive?
               failure(
                 check_id,
                 "#{due_count} scheduled job(s) are due but no dispatcher is running",
                 suggestion: 'Start a dispatcher process or verify bin/jobs is running'
               )
-            elsif due_count > config.scheduled_backlog_threshold
+            elsif due_count > threshold
               warn(
                 check_id,
-                "#{due_count} scheduled executions are due (threshold: #{config.scheduled_backlog_threshold})",
+                "#{due_count} scheduled executions are due (threshold: #{threshold})",
                 suggestion: 'Verify the dispatcher is keeping up with scheduled work'
               )
             else

data/lib/solid_queue_guard/checks/runtime/failed_jobs_check.rb

@@ -9,7 +9,7 @@ module SolidQueueGuard
         def call
           with_queue_database do
             count = SolidQueue::FailedExecution.where(created_at: WINDOW.ago..).count
-            threshold = config.failed_jobs_threshold
+            threshold = config.check_setting(:failed_jobs, :threshold, config.failed_jobs_threshold)
 
             if count > threshold
               warn(