rails_error_dashboard 0.14.3 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f96e195659bca5562fcf7c4ed02c1f8f69c058daec06f6902523958f5746a8a4
-  data.tar.gz: 2ea940fe412652bef9e0f47eb818d4da93a6d7b7cb1e32cd5820e96cf032fafe
+  metadata.gz: e4e3190d52a36d5c36abb07855ac5090194c0e7d3e426f38565724d60c4d54c2
+  data.tar.gz: 22c63cf4f49ee2f97b6898b3ab19e81bdf45f5c382a29c6c771c5d462d760dec
 SHA512:
-  metadata.gz: b7b8a36c5ffde9bcd71a0649a0d2df111345625717ec67a997e4bd4929215700408efd95844b41506e3a48aa47fc7179cd1df140aa1274451a1a8760a5f32db7
-  data.tar.gz: d6b3722433ce12451ef44242874dfe98620441832626368d0e8ce9d852396d8e4b00b5cc5773f04a348d48f64254fc763cd4fae4a1580d5b399cb4aab21f3de3
+  metadata.gz: fd736e679c40f293b58ad44b47f3215d001e45cd13c322d18f4033d178c8bc91242c018ccff8b676797d3282e1aa321e2ab15cc96050eabdd8bb3df42f6b7f63
+  data.tar.gz: '0696afc78d045942b741eaa166054455bd36b2962fb097cd67b7db8817c749243e3c70de3737c2e04aedd4b7cb52cd18ffb4d360a0b1d4805ff69e1ca4059716'

data/README.md

@@ -19,11 +19,11 @@ rails generate rails_error_dashboard:install
 rails db:migrate
 ```
 
-Open `/red` and raise a test exception. No monitoring account or ingestion service is required.
+Open `/red`, then send a test error from its Settings page. No monitoring account or ingestion service is required.
 
 [Try the live demo](https://rails-error-dashboard.anjan.dev) (`gandalf` / `youshallnotpass`) · [Read the documentation](https://anjanj.github.io/rails_error_dashboard/) · [View on RubyGems](https://rubygems.org/gems/rails_error_dashboard)
 
-> **Beta:** RED is functional and extensively tested, but configuration and APIs may change before 1.0. Supports Rails 7.0–8.1 and Ruby 3.2–4.0 (CI runs Ruby 3.2–3.4 against every supported Rails version; Ruby 4.0 is verified by the maintainer).
+> **Beta:** RED is functional and extensively tested, but configuration and APIs may change before 1.0. Supports Rails 7.0–8.1 and Ruby 3.2–4.0 (CI runs every Ruby from 3.2 to 4.0 against every supported Rails version).
 
 ## See the Ruby state and Rails runtime health behind every exception
 
@@ -91,7 +91,7 @@ That makes RED a self-hosted Sentry alternative for teams that want Rails-specif
 
 - Store data in the application's existing PostgreSQL, MySQL/Trilogy or SQLite database.
 - Isolate monitoring writes in a separate error database.
-- Use synchronous writes, or async logging through Sidekiq or Solid Queue (GoodJob is detected for job-health stats but is not an async adapter).
+- Use synchronous writes, or async logging through your app's own Active Job backend (Sidekiq, Solid Queue, GoodJob or Rails' in-process `:async`).
 - Track several Rails applications through a shared database.
 
 No RED licence or event-ingestion fee, and no plan limits — your database is the only cap, and storm protection deliberately sheds context during floods.
@@ -208,6 +208,8 @@ Cross-error N+1 detection grouped by SQL fingerprint, and aggregate deprecation
 
 Requires breadcrumbs to be enabled. Deprecations are seen only when the host's `ActiveSupport::Deprecation` behaviour includes `:notify` (the production default does not) and only inside requests that later raised.
 
+**Missing translations** — opt in with `config.enable_missing_translation_tracking = true` and RED counts every key your app looked up and did not have, by locale, with the first call site, on its own page. No breadcrumbs needed; it wraps `I18n.exception_handler` and delegates to the handler you already had. [Details →](docs/FEATURES.md#missing-translation-tracking)
+
 [Complete documentation →](docs/FEATURES.md#n1-query-detection)
 </details>
 
@@ -232,12 +234,14 @@ Requires breadcrumbs to be enabled. Deprecations are seen only when the host's `
 config.enable_actioncable_tracking = true  # requires enable_breadcrumbs = true
 ```
 
-**ActiveStorage Health** — Track file uploads, downloads, deletes, and existence checks across storage services (Disk, S3, GCS, Azure — any ActiveStorage backend). Dashboard page at `/errors/activestorage_health_summary` with per-service operation counts, average and slowest durations. Helps identify slow storage operations correlating with errors.
+**ActiveStorage Health** — Track file uploads, downloads, deletes, and existence checks across storage services (Disk, S3, GCS, Azure — any ActiveStorage backend). Dashboard page at `/errors/activestorage_health_summary` with per-service operation counts, average and slowest durations. Helps identify slow storage operations correlating with errors. The page opens with a live reachability card (one `exist?` for a key that is never stored, against the configured service), and `GET /error_dashboard/health` reports the same probe as its `active_storage` check.
 
 ```ruby
 config.enable_activestorage_tracking = true  # requires enable_breadcrumbs = true
 ```
 
+**Health Check** — `GET /error_dashboard/health` answers in JSON whether the dashboard itself can still capture and show errors: the error database (`SELECT 1`, tables present), last capture time, the Active Job adapter and Solid Queue config problems, the storm breaker state and the gem version. 503 when the error database is down, so an uptime monitor can watch the watchmen. Authenticated like every other route. [Reference →](docs/API_REFERENCE.md#health-check)
+
 [Complete documentation →](docs/FEATURES.md#job-health-page)
 </details>
 
@@ -430,7 +434,7 @@ config.llm_model = "gpt-5"
 </details>
 
 <details>
-<summary><strong>Notifications — Slack, Discord, PagerDuty, Email, Webhooks</strong></summary>
+<summary><strong>Notifications — Slack, Discord, Telegram, PagerDuty, Email, Webhooks</strong></summary>
 
 Multi-channel alerting with severity filters, per-error cooldown, milestone threshold alerts, and a per-environment allowlist (`config.notification_environments = %w[production]`) so a staging deploy never pages anyone.
 
@@ -439,6 +443,8 @@ config.enable_slack_notifications = true
 config.slack_webhook_url = ENV['SLACK_WEBHOOK_URL']
 ```
 
+Custom webhooks can carry an HMAC-SHA256 signature (`config.webhook_signing_secret`) so the receiver can verify the sender and reject replays.
+
 [Notification setup guide →](docs/guides/NOTIFICATIONS.md)
 </details>
 
@@ -556,7 +562,8 @@ config.enable_rack_attack_tracking = true
 Capture unhandled exceptions that crash the Ruby process via an `at_exit` hook — the last line of defense.
 
 - Disk-based fallback: writes crash data to disk because the database may be unavailable during shutdown
-- Imported automatically on next boot
+- Imported automatically on next boot; a crash that repeats on every restart is one row with a count
+- Boot crashes too: the hook is registered before Rails eager-loads, so a `Zeitwerk::NameError` or a `SyntaxError` that kills the process before it serves a request lands on the **Boot Errors** page under Diagnostics, with the file and constant it names
 - Captures exception details, backtrace, uptime, GC stats, thread count, and cause chain
 - Honeybadger, Bugsnag and AppSignal have `at_exit` reporters too; RED's writes to disk and imports at next boot because the database may already be gone during shutdown
 
@@ -619,6 +626,11 @@ Span names follow the `rails_error_dashboard.<operation>` convention, e.g. `rail
 gem 'rails_error_dashboard'
 ```
 
+RED requires Rails 7.0 or newer, Ruby 3.2 or newer, `pagy ~> 43` and `groupdate ~> 6`. An app that pins an older Pagy or groupdate must upgrade it first, or `bundle install` fails.
+
+- **Rails before 8.1.4 or 7.2.4** (every 8.0, 7.1 and 7.0 release): also add `gem "json", "< 3"`. json 3 breaks those Rails versions, and the dashboard returns 500. See [the json pin](docs/UPGRADING.md#rails-before-814-or-724-pin-json-below-3).
+- **MySQL**: load the time-zone tables (`mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -u root mysql`), or the charts fail.
+
 ### 2. Install with Interactive Setup
 
 ```bash
@@ -627,7 +639,9 @@ rails generate rails_error_dashboard:install
 rails db:migrate
 ```
 
-The installer guides you through optional feature selection — notifications, performance optimizations, advanced analytics. All features are opt-in.
+The installer asks about notifications and advanced analytics, then where to store errors: in your app's database (the default), a separate one, or one shared by several apps. Without a terminal (CI, Docker) it asks nothing: async logging is on, and every other optional feature is off.
+
+**Chose a separate or shared database?** Add the `config/database.yml` entry the installer prints, then run `bin/rails db:create` before `db:migrate`. See [Database Options](docs/guides/DATABASE_OPTIONS.md).
 
 ### 3. Visit your dashboard
 
@@ -637,17 +651,30 @@ http://localhost:3000/red
 
 Default credentials: `gandalf` / `youshallnotpass`, for development and test only.
 
-**Before you deploy anywhere else**, set `ERROR_DASHBOARD_USER` and `ERROR_DASHBOARD_PASSWORD` in that environment. Outside development and test, the app refuses to boot on the defaults. See [Dashboard Credentials](docs/guides/CONFIGURATION.md#dashboard-credentials).
+**Before you deploy anywhere else**, set `ERROR_DASHBOARD_USER` and `ERROR_DASHBOARD_PASSWORD` in that environment. Outside development and test, the app refuses to boot on the defaults. See [Dashboard Credentials](docs/guides/CONFIGURATION.md#dashboard-credentials). For the rest of what production needs (a worker, scheduled jobs, migrations on deploy), see [Running in Production](docs/PRODUCTION.md).
 
 ### 4. Test it out
 
+Open `/red/settings` and click **Send Test Error**, or raise an exception in any controller action. Errors raised at the Rails console prompt are not captured. To report one from the console, use:
+
 ```ruby
-# In Rails console or any controller
-raise "Test error from Rails Error Dashboard!"
+Rails.error.report(RuntimeError.new("Test error from Rails Error Dashboard"), handled: false)
 ```
 
+With async logging on (the default), leave the console open for a second or two so the background job can write it.
+
 [Full installation guide →](docs/QUICKSTART.md)
 
+### Upgrading
+
+```bash
+bundle update rails_error_dashboard
+bin/rails generate rails_error_dashboard:install --no-interactive
+bin/rails db:migrate
+```
+
+The installer keeps your initializer and copies only the new migrations. Some releases need a step of their own, and two of them can stop an app booting: [read the upgrade guide](docs/UPGRADING.md) before you deploy.
+
 ---
 
 ## Configuration
@@ -661,8 +688,7 @@ RailsErrorDashboard.configure do |config|
   # Optional features — enable as needed
   config.enable_slack_notifications = true
   config.slack_webhook_url = ENV['SLACK_WEBHOOK_URL']
-  config.async_logging = true
-  config.async_adapter = :sidekiq  # or :solid_queue, :async
+  config.async_logging = true  # jobs run on your app's Active Job adapter; production needs a worker
 end
 ```
 
@@ -670,7 +696,7 @@ end
 
 **Multi-App Support** — Track errors from multiple Rails apps in a single shared database. Auto-detects app name, supports per-app filtering. [Multi-App guide →](docs/MULTI_APP_PERFORMANCE.md)
 
-**OpenTelemetry Export** — Emit error-capture operations as OTel spans to Datadog, Honeycomb, or Jaeger. Add `gem "opentelemetry-api"` and set `config.enable_otel_export = true`. See [OpenTelemetry Export](#opentelemetry-export--emit-gem-operations-as-spans) above for full options.
+**OpenTelemetry Export** — Emit error-capture operations as OTel spans to Datadog, Honeycomb, or Jaeger. Add `gem "opentelemetry-api"` and set `config.enable_otel_export = true`. See **OpenTelemetry Export** under [Features](#features) above for the full options.
 
 ---
 
@@ -702,7 +728,7 @@ Users can also switch language per-session from the picker in the dashboard navb
 
 **Corrections are very welcome, and a one-key PR is a perfectly good PR.** If you read one of these languages, [every unreviewed locale has an open issue](https://github.com/AnjanJ/rails_error_dashboard/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation%3Aneeds-review) tracking its review — comment there, or [report a bad translation](https://github.com/AnjanJ/rails_error_dashboard/issues/new?template=translation_report.yml) without touching any code. You do not need to know Ruby, and you are not expected to review a whole file.
 
-RED translates through its own private I18n backend, so it never reads, writes or mutates your application's `I18n` configuration — your locale and its `available_locales` are untouched.
+RED translates through its own private I18n backend, so it never reads, writes or mutates your application's `I18n` configuration — your locale and its `available_locales` are untouched. The one exception is opt-in: `enable_missing_translation_tracking` wraps `I18n.exception_handler` to count *your* app's missing keys, and delegates every call to the handler you had.
 
 [Translations guide →](docs/guides/TRANSLATIONS.md) — how the system works, how to correct a string, and how to add a locale.
 
@@ -711,7 +737,7 @@ RED translates through its own private I18n backend, so it never reads, writes o
 ## FAQ
 
 **Does Rails Error Dashboard support a separate database for errors?**
-Yes. You can store errors in your app's existing database (shared) **or** in a dedicated, isolated database (separate). Set `config.use_separate_database = true` (or `USE_SEPARATE_ERROR_DB=true`) and point it at a separate connection — the engine routes all of its tables through `connects_to`, keeping error data fully isolated from your app data. Both modes are first-class and covered by the [Database Options guide](docs/guides/DATABASE_OPTIONS.md).
+Yes. You can store errors in your app's existing database **or** in a dedicated one. Choose it at the installer's database prompt (or pass `--separate-database`), then add the `error_dashboard` entry it prints to `config/database.yml` for every environment. The engine routes all of its tables through `connects_to`, keeping error data isolated from your app data. Both modes are first-class and covered by the [Database Options guide](docs/guides/DATABASE_OPTIONS.md).
 
 **Which databases does it work with?**
 SQLite, PostgreSQL, and MySQL/Trilogy — in either shared or separate-database mode.
@@ -726,13 +752,13 @@ Yes — local **and** instance variables at the moment the exception is raised,
 No. Storm protection (a circuit breaker with adaptive sampling, **ON by default**) makes the gem degrade itself first during error floods — occurrence counts stay exact while it sheds the expensive work, and a Storm History page shows exactly what was shed. There is no I/O on the hot path — the check is a digest and an atomic increment.
 
 **Does it work with my background jobs?**
-Yes — errors raised in jobs are captured, and it can log errors asynchronously through Sidekiq or SolidQueue (or the in-process `:async` adapter). Sidekiq, SolidQueue and GoodJob are all auto-detected for the job-queue stats stored on each error.
+Yes — errors raised in jobs are captured, and it can log errors asynchronously through your app's Active Job adapter (Sidekiq, Solid Queue, GoodJob or the in-process `:async`). In production, run a worker for the `default` and `error_notifications` queues. Sidekiq, Solid Queue and GoodJob are all auto-detected for the job-queue stats stored on each error.
 
 **Does it work with my authentication?**
 Yes — HTTP Basic Auth out of the box, or a custom `authenticate_with` lambda that integrates with Devise, Warden, or session-based auth.
 
 **Can it track more than one app?**
-Yes — multi-app support tracks errors from multiple Rails apps in one dashboard with per-app filtering.
+Yes — apps that point at the same error database share one dashboard, with per-app filtering.
 
 **What Rails and Ruby versions are supported?**
 Rails 7.0–8.1 and Ruby 3.2–4.0.
@@ -744,6 +770,8 @@ Rails 7.0–8.1 and Ruby 3.2–4.0.
 ### Getting Started
 - **[Quickstart Guide](docs/QUICKSTART.md)** — 5-minute setup
 - **[Configuration](docs/guides/CONFIGURATION.md)** — All configuration options
+- **[Upgrading](docs/UPGRADING.md)** — The upgrade, and the releases that need a step
+- **[Running in Production](docs/PRODUCTION.md)** — A worker, scheduled jobs and the other things RED needs before the first deploy
 - **[Uninstalling](docs/UNINSTALL.md)** — Clean removal
 
 ### Features

data/app/controllers/rails_error_dashboard/application_controller.rb

@@ -227,15 +227,39 @@ module RailsErrorDashboard
     end
 
     # Page size for every paginated action. Only the upper bound is enforced
-    # here: a value that is not a positive integer is passed through unchanged
-    # so that Pagy rejects it and the rescue above redirects, as it always has.
+    # here: a value Pagy would reject (0, a negative number, a Hash) is passed
+    # on so that it does and the rescue above redirects, as it always has.
+    #
+    # Strings are read the way Pagy reads them, with to_i, so the cap sees the
+    # same number Pagy would use: Integer() refused "150.5" and "0999" and the
+    # raw string went through, where Pagy's to_i made them 150 and 999.
     def per_page_param
       raw = params[:per_page]
       return DEFAULT_PER_PAGE if raw.blank?
 
-      number = Integer(raw, exception: false) if raw.is_a?(String)
-      number && number > MAX_PER_PAGE ? MAX_PER_PAGE : raw
+      value = raw.is_a?(String) ? raw.to_i : raw
+      value.is_a?(Integer) && value > MAX_PER_PAGE ? MAX_PER_PAGE : value
+    end
+
+    # The named query-string keys as a symbol-keyed Hash of their String values.
+    #
+    # Not params.permit: permit judges every key in the request, so a stray
+    # utm_source, or the `page` and `locale` the dashboard itself appends, was
+    # an "unpermitted parameter" on every index request. Under the default
+    # that is a log line; in a host with action_on_unpermitted_parameters =
+    # :raise it was a 500 on the errors page. Picking the keys we want and
+    # keeping only scalar values does what permit was meant to do here without
+    # passing judgement on the rest of the request.
+    #
+    # @param keys [Array<Symbol>]
+    # @return [Hash{Symbol => String}]
+    def scalar_params(keys)
+      keys.each_with_object({}) do |key, hash|
+        value = params[key]
+        hash[key] = value if value.is_a?(String)
+      end
     end
+    helper_method :scalar_params
 
     def render_dashboard_error(icon:, title:, message:, detail: nil, icon_style: nil, status: :internal_server_error)
       # The styled page runs queries and names the host app's applications. A

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -583,6 +583,52 @@ module RailsErrorDashboard
       @pagy, @events = pagy(:offset, all_events, limit: per_page_param)
     end
 
+    def missing_translations
+      unless RailsErrorDashboard.configuration.enable_missing_translation_tracking
+        flash[:alert] = feature_disabled_message("missing_translations", options: "enable_missing_translation_tracking = true", set: true)
+        redirect_to errors_path(**app_context_params)
+        return
+      end
+
+      days = days_param(default: 30)
+      @days = days
+      result = Queries::MissingTranslationSummary.call(days, application_id: @current_application_id)
+      all_entries = result[:entries]
+
+      # Summary stats (computed before pagination). The list is one row per
+      # (locale, key), so the badge and pagination count rows; the tile
+      # counts distinct keys, which is what "how many keys are missing" means.
+      @entry_count = all_entries.size
+      @unique_keys = all_entries.map { |e| e[:key] }.uniq.size
+      @total_misses = all_entries.sum { |e| e[:count] }
+      @locale_count = result[:locales].size
+      # Misses the tracker's bounded buffer dropped; shown so the total above
+      # is never silently understated.
+      @overflow_count = result[:overflow_count].to_i
+
+      @pagy, @entries = pagy(:offset, all_entries, limit: per_page_param)
+    end
+
+    def boot_errors
+      unless RailsErrorDashboard.configuration.enable_crash_capture
+        flash[:alert] = feature_disabled_message("boot_errors", options: "enable_crash_capture = true", set: true)
+        redirect_to errors_path(**app_context_params)
+        return
+      end
+
+      days = days_param(default: 30)
+      @days = days
+      result = Queries::BootErrors.call(days, application_id: @current_application_id)
+      all_entries = result[:entries]
+
+      # Summary stats (computed before pagination)
+      @entry_count = all_entries.size
+      @unresolved_count = result[:unresolved_count]
+      @total_occurrences = all_entries.sum { |e| e[:count] }
+
+      @pagy, @entries = pagy(:offset, all_entries, limit: per_page_param)
+    end
+
     def actioncable_health_summary
       unless RailsErrorDashboard.configuration.enable_actioncable_tracking &&
              RailsErrorDashboard.configuration.enable_breadcrumbs
@@ -634,6 +680,9 @@ module RailsErrorDashboard
 
       days = days_param(default: 30)
       @days = days
+      # Live reachability of the configured service, shown above the
+      # historical breadcrumb stats. One existence check per page load.
+      @storage_probe = Services::ActiveStorageProbe.call
       result = Queries::ActiveStorageSummary.call(days, application_id: @current_application_id)
       all_services = result[:services]
 
@@ -719,7 +768,17 @@ module RailsErrorDashboard
       )
       exception.set_backtrace(caller)
 
-      Commands::LogError.call(exception, { request: request, source: "dashboard.test_error" })
+      started_at = Time.current
+      error_log = Commands::LogError.call(exception, { request: request, source: "dashboard.test_error" })
+
+      # The capture path notifies on a first occurrence and then on the
+      # 10th, 50th... A second click within 24 hours is occurrence two of the
+      # same row, so it used to notify nobody, which reads as "notifications
+      # are broken". This button exists to prove delivery: if the capture
+      # path did not claim a notification in this request, send one now.
+      if error_log && !notified_since?(error_log, started_at)
+        Services::ErrorNotificationDispatcher.call(error_log)
+      end
 
       flash[:notice] = red_t("red.flash.test_error.logged")
       redirect_to errors_path(**app_context_params)
@@ -785,7 +844,14 @@ module RailsErrorDashboard
     end
 
     def filter_params
-      params.permit(*FILTERABLE_PARAMS).to_h.symbolize_keys
+      scalar_params(FILTERABLE_PARAMS)
+    end
+
+    # True when NotificationThrottler claimed a notification for this error
+    # at or after +since+. The claim is an update_all, so the row is re-read.
+    def notified_since?(error_log, since)
+      stamp = error_log.class.where(id: error_log.id).pick(:last_notified_at)
+      stamp.present? && stamp >= since
     end
 
     # Coerce params[:days] into a sane integer in [1, 365]. Without clamping,

data/app/controllers/rails_error_dashboard/health_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # GET /health — can the dashboard itself still capture and show errors?
+  #
+  # JSON only, for an uptime monitor: 200 when the error database answers,
+  # 503 when it does not (status "down"). "degraded" (a storm in progress,
+  # a Solid Queue config that will not run RED's jobs) is still a 200: the
+  # dashboard works, with a caveat the body spells out. See
+  # Queries::HealthStatus for what is probed and why.
+  #
+  # Authenticated like every other dashboard route (ApplicationController
+  # prepends the filter): the body names the database adapter and the queue
+  # backend, which is more than an anonymous caller should learn. Basic auth
+  # works from any monitor; with authenticate_with, point the monitor at
+  # whatever that lambda accepts.
+  #
+  # Its own controller rather than an ErrorsController action: no
+  # application context, no storm banner, no error data is loaded here.
+  class HealthController < ApplicationController
+    # ApplicationController's handler renders the HTML error page. A health
+    # endpoint must answer in JSON whatever happens, so this one, declared
+    # later, takes precedence.
+    rescue_from StandardError do |exception|
+      Rails.logger.error("[RailsErrorDashboard] Health check failed: #{exception.class} - #{exception.message}")
+      render json: { status: Queries::HealthStatus::DOWN, version: RailsErrorDashboard::VERSION,
+                     error: exception.class.name },
+             status: :service_unavailable
+    end
+
+    def show
+      result = Queries::HealthStatus.call
+
+      response.headers["Cache-Control"] = "no-store"
+      render json: result, status: Queries::HealthStatus.http_status_for(result)
+    end
+  end
+end

data/app/helpers/rails_error_dashboard/application_helper.rb

@@ -1,5 +1,13 @@
 module RailsErrorDashboard
   module ApplicationHelper
+    # Problems in config/queue.yml that stop RED's jobs in this environment:
+    # empty when the config is fine, or when Solid Queue doesn't run RED's jobs.
+    def red_solid_queue_problems
+      Services::SolidQueueConfigCheck.current_problems
+    rescue StandardError
+      []
+    end
+
     # Returns the host app's CSP nonce (if any) so inline <script> tags pass strict CSP.
     # Falls back to nil when the host has no CSP configured — in that case the script tag
     # works without a nonce attribute. Strict CSPs (script-src 'self' 'nonce-...') require
@@ -155,8 +163,8 @@ module RailsErrorDashboard
     # @return [Hash] Whitelisted params for building URLs
     def permitted_filter_params(extra_keys: [])
       base_keys = RailsErrorDashboard::ErrorsController::FILTERABLE_PARAMS + %i[page per_page days]
-      allowed_keys = base_keys + Array(extra_keys)
-      params.permit(*allowed_keys).to_h.symbolize_keys
+      # scalar_params, not params.permit: see ApplicationController#scalar_params.
+      scalar_params(base_keys + Array(extra_keys))
     end
 
     # Generates a sortable column header link

data/app/helpers/rails_error_dashboard/backtrace_helper.rb

@@ -7,6 +7,59 @@ module RailsErrorDashboard
     # one view context.
     include I18nHelper
 
+    # The brand name for a repository link's tooltip, from the URL's host.
+    # A substring test on the whole URL called every non-GitHub, non-GitLab
+    # host "Bitbucket", Codeberg included, and a path containing "github"
+    # mislabelled any host.
+    def repository_host_label(url)
+      host = URI.parse(url.to_s).host.to_s.downcase
+      case host
+      when /github/    then "GitHub"
+      when /gitlab/    then "GitLab"
+      when /bitbucket/ then "Bitbucket"
+      when /codeberg/  then "Codeberg"
+      when /gitea/     then "Gitea"
+      when /forgejo/   then "Forgejo"
+      else host.presence || "Repository"
+      end
+    rescue URI::InvalidURIError
+      "Repository"
+    end
+
+    # The error-info fragment renders the source viewer, blame, repository
+    # links and the coverage overlay, none of which come from the error row
+    # the fragment is keyed on. These three helpers put the rest of the key's
+    # inputs in: the configuration those parts depend on, the source cache
+    # TTL as the fragment's lifetime, and no caching at all while coverage is
+    # active, because that overlay is live data.
+    def source_view_cache_key
+      config = RailsErrorDashboard.configuration
+      # The gem version too, for the same reason as read_source_code's key
+      parts = [
+        RailsErrorDashboard::VERSION,
+        config.enable_source_code_integration, config.enable_git_blame, config.only_show_app_code_source,
+        config.git_repository_url, config.git_branch_strategy
+      ]
+      Digest::SHA1.hexdigest(parts.map(&:to_s).join("|"))[0, 12]
+    rescue StandardError
+      "nocfg"
+    end
+
+    def source_view_cacheable?
+      !(defined?(Services::CoverageTracker) && Services::CoverageTracker.active?)
+    rescue StandardError
+      true
+    end
+
+    def source_view_cache_options
+      config = RailsErrorDashboard.configuration
+      return {} unless config.enable_source_code_integration
+
+      { expires_in: (config.source_code_cache_ttl || 3600).to_i.seconds }
+    rescue StandardError
+      {}
+    end
+
     # Language mapping for syntax highlighting
     LANGUAGE_MAP = {
       ".rb" => "ruby",
@@ -152,8 +205,9 @@ module RailsErrorDashboard
       return nil unless RailsErrorDashboard.configuration.enable_source_code_integration
       return nil unless frame[:file_path] && frame[:line_number]
 
-      # Cache key includes file path, line number, and git SHA if available
-      cache_key = "source_code/#{frame[:file_path]}/#{frame[:line_number]}"
+      # The gem version is in the key: a cached read must not outlive a change
+      # to the reader's rules for which files it may read.
+      cache_key = "source_code/#{RailsErrorDashboard::VERSION}/#{frame[:file_path]}/#{frame[:line_number]}"
       cache_ttl = RailsErrorDashboard.configuration.source_code_cache_ttl || 3600
 
       Rails.cache.fetch(cache_key, expires_in: cache_ttl) do

data/app/jobs/rails_error_dashboard/baseline_alert_job.rb

@@ -59,6 +59,11 @@ module RailsErrorDashboard
         send_discord_notification(error_log, anomaly_data, config, locale)
       end
 
+      # Telegram notification
+      if Services::TelegramDelivery.configured?(config)
+        send_telegram_notification(error_log, anomaly_data, config, locale)
+      end
+
       # Webhook notification
       if config.enable_webhook_notifications && config.webhook_urls.any?
         send_webhook_notification(error_log, anomaly_data, config, locale)
@@ -96,11 +101,24 @@ module RailsErrorDashboard
       Rails.logger.error("Failed to send baseline alert to Discord: #{e.message}")
     end
 
+    def send_telegram_notification(error_log, anomaly_data, _config, locale)
+      payload = Services::BaselineAlertPayloadBuilder.telegram_payload(error_log, anomaly_data, locale: locale)
+
+      Services::TelegramDelivery.post(payload)
+    rescue => e
+      Rails.logger.error("Failed to send baseline alert to Telegram: #{Services::TelegramDelivery.redact(e.message)}")
+    end
+
     def send_webhook_notification(error_log, anomaly_data, config, locale)
       payload = Services::BaselineAlertPayloadBuilder.webhook_payload(error_log, anomaly_data, locale: locale)
 
+      # Signed when webhook_signing_secret is set; Slack and Discord above
+      # keep post_json because their payloads are not ours to sign. Rescued
+      # per URL so one unreachable receiver does not stop the next.
       config.webhook_urls.each do |url|
-        post_json(url, payload)
+        Services::WebhookDelivery.post(url, payload)
+      rescue => e
+        Rails.logger.error("Failed to send baseline alert to webhook: #{e.message}")
       end
     rescue => e
       Rails.logger.error("Failed to send baseline alert to webhook: #{e.message}")
@@ -116,7 +134,7 @@ module RailsErrorDashboard
         http.use_ssl = uri.scheme == "https"
         http.open_timeout = 5
         http.read_timeout = 10
-        request = Net::HTTP::Post.new(uri.path, { "Content-Type" => "application/json" })
+        request = Net::HTTP::Post.new(uri.request_uri, { "Content-Type" => "application/json" })
         request.body = payload.to_json
         http.request(request)
       end

data/app/jobs/rails_error_dashboard/cascade_detection_job.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Finds error cascades (A reliably followed by B) in recent occurrences and
+  # upserts them as CascadePattern rows, which the error page's Cascades card
+  # reads.
+  #
+  # Nothing in the gem schedules this: run it from the host's scheduler like
+  # the other periodic jobs (docs/PRODUCTION.md). Before this job existed the
+  # docs said cascades were detected "hourly" by a background job that no
+  # code path ever ran, so the card stayed empty on every install.
+  #
+  # Use a lookback equal to the interval it runs at: an hourly run with a
+  # 24-hour lookback re-counts the same pairs 24 times a day.
+  class CascadeDetectionJob < ApplicationJob
+    queue_as :default
+
+    # @param lookback_hours [Integer] the window of occurrences to scan
+    def perform(lookback_hours: 1)
+      return { detected: 0, updated: 0, skipped: "enable_error_cascades is off" } unless RailsErrorDashboard.configuration.enable_error_cascades
+
+      result = Services::CascadeDetector.call(lookback_hours: lookback_hours.to_i.clamp(1, 24 * 30))
+      Rails.logger.info("[RailsErrorDashboard] Cascade detection: #{result[:detected]} detected, #{result[:updated]} updated")
+      result
+    rescue => e
+      Rails.logger.error("[RailsErrorDashboard] CascadeDetectionJob failed: #{e.class}: #{e.message}")
+      raise
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/concerns/plain_channel_message.rb

@@ -11,9 +11,10 @@ module RailsErrorDashboard
     module PlainChannelMessage
       private
 
-      # Slack takes {text:}, Discord {content:}, custom webhooks a
-      # machine-readable event. Email and PagerDuty are not used: neither has
-      # a sensible shape for a message that is not an incident.
+      # Slack takes {text:}, Discord {content:}, Telegram a plain sendMessage,
+      # custom webhooks a machine-readable event. Email and PagerDuty are not
+      # used: neither has a sensible shape for a message that is not an
+      # incident.
       def deliver_plain_message(message, webhook_payload)
         config = RailsErrorDashboard.configuration
         delivered = false
@@ -28,15 +29,20 @@ module RailsErrorDashboard
           delivered = true
         end
 
+        if Services::TelegramDelivery.configured?(config)
+          post_telegram(message)
+          delivered = true
+        end
+
         if config.enable_webhook_notifications && config.webhook_urls.present?
-          config.webhook_urls.each { |url| post_json(url, webhook_payload) }
+          config.webhook_urls.each { |url| post_webhook(url, webhook_payload) }
           delivered = true
         end
 
         # An email-only or PagerDuty-only deployment has no channel for this.
         # Say so where an operator can find it rather than dropping it silently.
         unless delivered
-          Rails.logger.warn("[RailsErrorDashboard] #{self.class.name.demodulize}: no Slack, Discord or webhook channel is enabled; message not sent: #{message}")
+          Rails.logger.warn("[RailsErrorDashboard] #{self.class.name.demodulize}: no Slack, Discord, Telegram or webhook channel is enabled; message not sent: #{message}")
         end
       end
 
@@ -49,6 +55,27 @@ module RailsErrorDashboard
           (defined?(Rails) && Rails.application.class.module_parent_name) || "Rails Application"
       end
 
+      # Custom webhooks go through WebhookDelivery so they are signed when
+      # webhook_signing_secret is set. Slack and Discord stay on post_json:
+      # their payloads are not ours to sign. Same per-URL rescue as post_json,
+      # so one unreachable receiver does not stop the next.
+      def post_webhook(url, payload)
+        Services::WebhookDelivery.post(url, payload)
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] #{self.class.name.demodulize} post failed: #{e.message}")
+      end
+
+      # No parse_mode: the sentence is sent verbatim, so an app name with a
+      # "<" in it cannot break Telegram's HTML parser. The token sits in the
+      # request URL, hence the redaction before logging.
+      def post_telegram(message)
+        Services::TelegramDelivery.send_message(message)
+      rescue => e
+        Rails.logger.error(
+          "[RailsErrorDashboard] #{self.class.name.demodulize} Telegram post failed: #{Services::TelegramDelivery.redact(e.message)}"
+        )
+      end
+
       def post_json(url, payload)
         if defined?(HTTParty)
           HTTParty.post(url, body: payload.to_json,
@@ -59,7 +86,7 @@ module RailsErrorDashboard
           http.use_ssl = uri.scheme == "https"
           http.open_timeout = 5
           http.read_timeout = 10
-          request = Net::HTTP::Post.new(uri.path, { "Content-Type" => "application/json" })
+          request = Net::HTTP::Post.new(uri.request_uri, { "Content-Type" => "application/json" })
           request.body = payload.to_json
           http.request(request)
         end

data/app/jobs/rails_error_dashboard/discord_error_notification_job.rb

@@ -32,7 +32,7 @@ module RailsErrorDashboard
         http.use_ssl = uri.scheme == "https"
         http.open_timeout = 5
         http.read_timeout = 10
-        request = Net::HTTP::Post.new(uri.path, { "Content-Type" => "application/json" })
+        request = Net::HTTP::Post.new(uri.request_uri, { "Content-Type" => "application/json" })
         request.body = payload.to_json
         http.request(request)
       end