rails_error_dashboard 0.11.4 → 0.11.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1641d82898e05eb9bd08a04a01516952e0c8c08cec1f20ad7385894c2abcc0b8
-  data.tar.gz: 3612aecf1b1ea06f75258ea9adbdbef68a5079d338061e3ad08ddb8fa571d37a
+  metadata.gz: 31b48d634cb3ef3737bfc4744993cd315deec8555bc6a0a7da55d6a3e3b011d5
+  data.tar.gz: 32fbeecb52dcbb0b48bf3f10f9fcc6da854ac20e0f1236a8fe0d37d1a3288475
 SHA512:
-  metadata.gz: ad234969bb94a719add01ad7453bd265209c07aa1b7502b74b6cbddf6180fea772017fc67991b6e9bfd7b08d6b9ff24d8ca1cea3502a5e25723022f742511a80
-  data.tar.gz: d687753f2eaea1bb9b9fe2eefa7c5f1f4810770a4ca1b93779e9b7e1203ffbeecc66cf488c7b1c4e649044ba84171be4f07eafd30193e4169711a7665aa3cf16
+  metadata.gz: 76346c5b3c5b5ba64e272d27024dc29a4635eca2024458a10b1eff9b0a842dd5cb96bbd671566d59ce3b53f44d5ca7d61250f4f620f6b4e0e4212f09d2c884d4
+  data.tar.gz: e9fcc3afb33b3d550c830453e1d8e1325081e6f182103975855dc337c56ea1735fbfccc3879b8af35cb1fdb119eb925ccff5b516108a2eb9d3eb300ff5094e8f

data/README.md

@@ -184,7 +184,7 @@ config.enable_breadcrumbs = true
 
 Know your app's runtime state at the moment of failure — GC stats, process memory, thread count, connection pool utilization, Puma thread stats, RubyVM cache health, YJIT compilation stats, and deep runtime insights captured automatically.
 
-- Sub-millisecond total snapshot, every metric individually rescue-wrapped
+- Sub-millisecond for the in-process metrics, every metric individually rescue-wrapped. The one exception is job-queue depth (five `COUNT`s for Solid Queue, a Redis round-trip for Sidekiq): those are queries against your queue store, cached for 10 s per process and switchable off with `config.system_health_queue_stats = false`
 - No ObjectSpace scanning, no Thread backtraces, no subprocess calls
 - RubyVM.stat: constant cache invalidations, shape cache stats
 - YJIT runtime stats: compiled iseqs, invalidation count, code region sizes
@@ -476,9 +476,10 @@ Seven analysis engines built in:
 <details>
 <summary><strong>Local Variable + Instance Variable Capture</strong></summary>
 
-See the exact values of local variables and instance variables at the moment an exception was raised — the most valuable debugging context possible.
+See the values of local variables and instance variables at the moment an exception was raised — the most valuable debugging context possible.
 
 - TracePoint(`:raise`) captures locals and ivars before the stack unwinds
+- Strings, arrays and hashes are snapshotted at raise time (one level deep, bounded by the limits below), so an `ensure` block that cleans up state does not overwrite what you see. Other objects are kept by reference and show their state at serialization time
 - Configurable limits: max variable count, nesting depth, string truncation length
 - Sensitive data auto-filtered via Rails `filter_parameters` — passwords, tokens, and PII never stored
 - Never stores Binding objects — values extracted immediately, Binding is GC'd

data/app/jobs/rails_error_dashboard/async_error_logging_job.rb

@@ -37,8 +37,16 @@ module RailsErrorDashboard
     # Reconstruct exception from serialized data
     # @param data [Hash] Serialized exception data
     # @return [Exception] Reconstructed exception object
+    #
+    # Never relies on the subclass constructor: many real exception classes
+    # take something other than a message (ActiveRecord::RecordInvalid wants
+    # the record, custom errors take keywords), and `Klass.new(message)` on
+    # those raised inside the job, which rescued it and dropped the capture.
+    # Allocate the right class so error_type/fingerprint stay correct, then
+    # set the message with Exception's own initializer, bypassing whatever
+    # the subclass expects. Fall back to the constructor for classes whose
+    # `message` needs state their initializer sets.
     def reconstruct_exception(data)
-      # Get or create the exception class
       exception_class = begin
         data[:class_name].constantize
       rescue NameError
@@ -46,13 +54,33 @@ module RailsErrorDashboard
         StandardError
       end
 
-      # Create new exception with the original message
-      exception = exception_class.new(data[:message])
+      exception = allocate_exception(exception_class, data[:message]) ||
+                  construct_exception(exception_class, data[:message]) ||
+                  StandardError.new(data[:message])
 
       # Restore the backtrace
       exception.set_backtrace(data[:backtrace]) if data[:backtrace]
 
       exception
     end
+
+    def allocate_exception(exception_class, message)
+      return nil unless exception_class < Exception
+
+      exception = exception_class.allocate
+      Exception.instance_method(:initialize).bind_call(exception, message)
+      exception.message # a subclass `message` that needs constructor state raises here
+      exception
+    rescue StandardError, NoMemoryError
+      nil
+    end
+
+    def construct_exception(exception_class, message)
+      exception = exception_class.new(message)
+      exception.message
+      exception
+    rescue StandardError
+      nil
+    end
   end
 end

data/app/jobs/rails_error_dashboard/baseline_calculation_job.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Recalculates every error-type/platform baseline from recent history.
+  #
+  # Nothing in the gem schedules this: run it from the host's scheduler
+  # (Solid Queue recurring tasks, sidekiq-cron, whenever, cron + runner)
+  # roughly daily. Without it there are no baselines and no baseline alerts.
+  class BaselineCalculationJob < ApplicationJob
+    queue_as :default
+
+    def perform
+      result = Services::BaselineCalculator.calculate_all_baselines
+      Rails.logger.info("[RailsErrorDashboard] Baselines recalculated: #{result[:calculated]}")
+      result
+    rescue => e
+      Rails.logger.error("[RailsErrorDashboard] BaselineCalculationJob failed: #{e.class}: #{e.message}")
+      raise
+    end
+  end
+end

data/app/models/rails_error_dashboard/error_log.rb

@@ -339,13 +339,10 @@ module RailsErrorDashboard
       return { anomaly: false, message: "Feature disabled" } unless RailsErrorDashboard.configuration.enable_baseline_alerts
       return { anomaly: false, message: "No baseline available" } unless defined?(Queries::BaselineStats)
 
-      # Get count of this error type today
-      today_count = ErrorLog.where(
-        error_type: error_type,
-        platform: platform
-      ).where("occurred_at >= ?", Time.current.beginning_of_day).count
-
-      Queries::BaselineStats.new(error_type, platform).check_anomaly(today_count, sensitivity: sensitivity)
+      # Current hour / day / week counted in the baselines' own units — a
+      # day's count against an hourly baseline flagged everything.
+      Queries::BaselineStats.new(error_type, platform)
+                            .check_current_anomaly(sensitivity: sensitivity, application_id: application_id)
     end
 
     # Detect cyclical occurrence patterns (daily/weekly rhythms)

data/app/models/rails_error_dashboard/error_logs_record.rb

@@ -34,5 +34,39 @@ module RailsErrorDashboard
     # Database connection will be configured by the engine initializer
     # after the user's configuration is loaded
     # See lib/rails_error_dashboard/engine.rb
+
+    # Rails' default for a string column when the adapter has one (MySQL).
+    DEFAULT_STRING_LIMIT = 255
+
+    # Truncate string-typed attributes to their column limits. MySQL in strict
+    # mode rejects an over-long value outright, the capture path rescues the
+    # failure, and the error is silently lost — over a 300-character app
+    # version. Columns without a declared limit are clamped to the Rails
+    # default so behaviour is the same on every adapter. Text columns are
+    # untouched. Identity (error_hash) is computed from the raw values before
+    # this runs, so clamping display metadata never changes grouping.
+    # @param attributes [Hash] attribute name => value
+    # @return [Hash] a copy with over-long strings truncated
+    def self.clamp_string_attributes(attributes)
+      limits = string_column_limits
+      attributes.each_with_object({}) do |(name, value), clamped|
+        limit = limits[name.to_s]
+        clamped[name] = if limit && value.is_a?(String) && value.length > limit
+          value[0, limit]
+        else
+          value
+        end
+      end
+    rescue => e
+      RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] clamp_string_attributes failed: #{e.message}")
+      attributes
+    end
+
+    # @return [Hash] column name => character limit, string columns only (memoized per class)
+    def self.string_column_limits
+      @string_column_limits ||= columns_hash.each_with_object({}) do |(name, column), limits|
+        limits[name] = column.limit || DEFAULT_STRING_LIMIT if column.type == :string
+      end
+    end
   end
 end

data/config/locales/fr.yml

@@ -59,7 +59,7 @@ fr:
       activestorage: ActiveStorage
       llm: LLM
       n_plus_one: Requêtes N+1
-      deprecations: Deprecations
+      deprecations: Dépréciations
       swallowed: Avalées
       diagnostic_dumps: Diagnostics
       storms: Tempêtes
@@ -265,7 +265,7 @@ fr:
           analytics: Analyse
       variables:
         local_title: Variables locales
-        local_hint: Variables de la frame de pile où l'exception a été levée
+        local_hint: Variables de la stack frame où l'exception a été levée
         instance_title: Variables d'instance
         instance_hint_html: Variables d'instance de %{klass}, là où l'exception a
           été levée
@@ -281,11 +281,11 @@ fr:
         filtered: "[FILTRÉE]"
         truncated: tronquée
       deprecations:
-        title: Avertissements de deprecation
-        hint: Avertissements de deprecation Rails détectés pendant cette requête
+        title: Avertissements de dépréciation
+        hint: Avertissements de dépréciation Rails détectés pendant cette requête
         column_warning: Avertissement
         column_source: Source
-        footer_tip: Corrigez les deprecations avant de mettre Rails à jour pour éviter
+        footer_tip: Corrigez les dépréciations avant de mettre Rails à jour pour éviter
           les changements incompatibles.
         upgrade_guide: Guide de mise à jour de Rails
       n_plus_one:
@@ -789,17 +789,17 @@ fr:
           jours.
         how_breadcrumbs_html: Les breadcrumbs doivent être activés (%{option})
       deprecations_page:
-        title: Avertissements de deprecation
-        empty_title: Aucun avertissement de deprecation trouvé
-        empty_body: Aucun avertissement de deprecation n'a été détecté dans les breadcrumbs
+        title: Avertissements de dépréciation
+        empty_title: Aucun avertissement de dépréciation trouvé
+        empty_body: Aucun avertissement de dépréciation n'a été détecté dans les breadcrumbs
           d'erreur des %{days} derniers jours.
-        how_title: 'Comment les deprecations sont capturées :'
-        how_captured: Les avertissements de deprecation de Rails sont capturés automatiquement
+        how_title: 'Comment les dépréciations sont capturées :'
+        how_captured: Les avertissements de dépréciation de Rails sont capturés automatiquement
           comme breadcrumbs
-        how_appear: Les deprecations apparaissent ici lorsqu'une erreur survient pendant
-          une requête comportant des avertissements de deprecation
+        how_appear: Les dépréciations apparaissent ici lorsqu'une erreur survient pendant
+          une requête comportant des avertissements de dépréciation
         unique_warnings: Avertissements uniques
-        all_title: Tous les avertissements de deprecation
+        all_title: Tous les avertissements de dépréciation
         column_warning: Avertissement
         column_source: Source
       n_plus_one_page:
@@ -885,7 +885,7 @@ fr:
         docs: Documentation de Rack Attack
       diagnostic_dumps_page:
         title: Dumps de diagnostic
-        capture: Créer un dump
+        capture: Prendre un dump
         empty_title: Aucun dump de diagnostic pour l'instant
         empty_body: Créez à la demande un instantané de l'état de votre système à
           des fins de débogage.
@@ -1147,7 +1147,7 @@ fr:
           via SolidQueue, Sidekiq ou cron
         digest_frequency: Fréquence d'envoi des e-mails de résumé
         digest_recipients: Adresses e-mail (à défaut, les destinataires des notifications)
-        enable_similar_errors: Trouver les erreurs proches par similarité
+        enable_similar_errors: Trouver les erreurs similaires
         enable_co_occurring_errors: Erreurs survenant conjointement
         enable_error_cascades: Chaînes d'erreurs parent → enfant
         enable_error_correlation: Analyse par version, utilisateur et heure
@@ -1158,7 +1158,7 @@ fr:
         baseline_alert_severities: Gravités donnant lieu à une alerte
         baseline_alert_cooldown_minutes: Minutes entre deux alertes pour le même type
           d'erreur
-        enable_source_code_integration: Afficher le code dans le backtrace
+        enable_source_code_integration: Afficher le code dans la backtrace
         source_code_context_lines: Lignes avant et après la ligne ciblée
         enable_git_blame: Afficher les informations git blame
         source_code_cache_ttl: Durée de mise en cache du code source
@@ -1760,7 +1760,7 @@ fr:
           age_days: "%{days} jours"
           view: Voir
         releases:
-          version_chart_title: Erreurs par version de release
+          version_chart_title: Erreurs par version
           comparison_title: Dernière par rapport à la précédente
           latest_version: Dernière version
           latest_errors:
@@ -1781,9 +1781,9 @@ fr:
             other: "%{count} critiques"
             many: "%{count} critiques"
           change: Variation
-          empty: Données de release insuffisantes pour une comparaison.
-          problematic_title: Releases problématiques détectées
-          problematic_hint_html: 'Les releases suivantes présentent des taux d''erreur
+          empty: Données de version insuffisantes pour une comparaison.
+          problematic_title: Versions problématiques détectées
+          problematic_hint_html: 'Les versions suivantes présentent des taux d''erreur
             nettement plus élevés (>%{multiplier}x la moyenne) :'
           problematic_entry: "%{count} erreurs (%{critical} critiques, +%{deviation}
             % par rapport à la moyenne)"
@@ -1909,10 +1909,10 @@ fr:
       releases:
         title: Releases
         empty:
-          title: Aucune donnée de release trouvée
+          title: Aucune donnée de version trouvée
           message: Aucune donnée de version n'a été détectée dans les erreurs des
             %{days} derniers jours.
-          how_to_title: 'Comment activer le suivi des releases :'
+          how_to_title: 'Comment activer le suivi des versions :'
           step_config_html: Définissez %{option} dans votre initializer
           step_env_html: Ou définissez la variable d'environnement %{env_var}
           step_git_sha_html: Le SHA Git est détecté automatiquement depuis %{git_sha},
@@ -1920,12 +1920,12 @@ fr:
           step_captured: La version et le SHA sont capturés automatiquement lorsque
             des erreurs surviennent
         summary:
-          releases: Releases
-          current_release: Release actuelle
-          avg_errors: Erreurs moy. par release
-          problematic: Releases problématiques
+          releases: Versions
+          current_release: Version actuelle
+          avg_errors: Erreurs moy. par version
+          problematic: Versions problématiques
         current_card:
-          title: 'Release actuelle :'
+          title: 'Version actuelle :'
           live_badge: En ligne
           errors: Erreurs
           error_types: Types d'erreurs
@@ -1934,7 +1934,7 @@ fr:
           git_sha: SHA Git
           vs_previous: Par rapport à la précédente
         timeline:
-          title: Chronologie des releases
+          title: Chronologie des versions
           column_version: Version
           column_git_sha: SHA Git
           column_time_range: Période
@@ -1954,7 +1954,7 @@ fr:
             moyenne des erreurs, <span class="badge bg-warning">Jaune</span> 1 à 2x
             la moyenne, <span class="badge bg-danger">Rouge</span> &gt; 2x la moyenne.
             Les « nouvelles » erreurs sont les types d''erreurs apparus pour la première
-            fois dans cette release.'
+            fois dans cette version.'
       user_impact:
         title: Impact utilisateur
         empty:
@@ -2087,7 +2087,7 @@ fr:
       sections:
         error: Erreur
         request: Requête
-        deprecations: Deprecations
+        deprecations: Dépréciations
         n_plus_one: N+1
         cache: Cache
         breadcrumbs: Breadcrumbs

data/db/migrate/20260908000001_add_release_to_error_occurrences.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Release attribution belongs on the occurrence, not the group.
+#
+# An ErrorLog row is a GROUP: it keeps the app_version/git_sha of the first
+# capture in its window and recurrences do not touch them. So an error first
+# seen in v1 that kept firing after the v2 deploy was reported entirely under
+# v1, and the release timeline could not answer "did this deploy make things
+# worse". Each ErrorOccurrence now records the release it happened under, and
+# ReleaseTimeline counts occurrences per release.
+#
+# Existing occurrences are backfilled from their group's release. That is the
+# same attribution the dashboard showed before this migration (no worse), and
+# it keeps historical releases populated instead of dropping to zero.
+class AddReleaseToErrorOccurrences < ActiveRecord::Migration[7.0]
+  def up
+    return if column_exists?(:rails_error_dashboard_error_occurrences, :app_version)
+
+    add_column :rails_error_dashboard_error_occurrences, :app_version, :string
+    add_column :rails_error_dashboard_error_occurrences, :git_sha, :string
+    add_index :rails_error_dashboard_error_occurrences, [ :app_version, :occurred_at ],
+              name: "index_error_occurrences_on_version_and_time"
+
+    # Correlated subqueries rather than UPDATE ... FROM / JOIN: the one form
+    # SQLite, PostgreSQL and MySQL all accept.
+    execute <<~SQL.squish
+      UPDATE rails_error_dashboard_error_occurrences
+      SET app_version = (
+            SELECT app_version FROM rails_error_dashboard_error_logs
+            WHERE rails_error_dashboard_error_logs.id = rails_error_dashboard_error_occurrences.error_log_id
+          ),
+          git_sha = (
+            SELECT git_sha FROM rails_error_dashboard_error_logs
+            WHERE rails_error_dashboard_error_logs.id = rails_error_dashboard_error_occurrences.error_log_id
+          )
+      WHERE app_version IS NULL
+    SQL
+  end
+
+  def down
+    remove_index :rails_error_dashboard_error_occurrences, name: "index_error_occurrences_on_version_and_time"
+    remove_column :rails_error_dashboard_error_occurrences, :git_sha
+    remove_column :rails_error_dashboard_error_occurrences, :app_version
+  end
+end

data/lib/rails_error_dashboard/commands/find_or_increment_error.rb

@@ -4,6 +4,10 @@ module RailsErrorDashboard
   module Commands
     # Command: Find an existing error by hash or create a new one
     # Uses pessimistic locking to prevent race conditions in multi-app scenarios.
+    # The whole find-and-write runs inside ONE transaction: a row lock taken
+    # by SELECT ... FOR UPDATE lives only as long as the transaction that took
+    # it, so a lock on a standalone SELECT was released before the UPDATE ran
+    # and two concurrent captures could both read count N and both write N+1.
     #
     # Search order:
     # 1. Unresolved errors with same hash within 24 hours → increment occurrence count
@@ -37,16 +41,18 @@ module RailsErrorDashboard
       end
 
       def call
-        # Priority 1: Find unresolved match (existing behavior)
-        existing = find_unresolved
-        return increment_existing(existing) if existing
+        ErrorLog.transaction do
+          # Priority 1: Find unresolved match (existing behavior)
+          existing = find_unresolved
+          next increment_existing(existing) if existing
 
-        # Priority 2: Find resolved/wont_fix match → reopen
-        resolved = find_resolved
-        return reopen_existing(resolved) if resolved
+          # Priority 2: Find resolved/wont_fix match → reopen
+          resolved = find_resolved
+          next reopen_existing(resolved) if resolved
 
-        # Priority 3: Create new record
-        create_new_or_retry
+          # Priority 3: Create new record
+          create_new_or_retry
+        end
       end
 
       private
@@ -132,7 +138,12 @@ module RailsErrorDashboard
       end
 
       def create_new_or_retry
-        ErrorLog.create!(@attributes.reverse_merge(resolved: false))
+        # Savepoint: on PostgreSQL a unique-violation poisons the enclosing
+        # transaction, and the retry lookups below would fail with "current
+        # transaction is aborted" instead of finding the winner's row.
+        ErrorLog.transaction(requires_new: true) do
+          ErrorLog.create!(@attributes.reverse_merge(resolved: false))
+        end
       rescue ActiveRecord::RecordNotUnique
         # Race condition: another process created the same error
         retry_existing = with_environment(

data/lib/rails_error_dashboard/commands/flush_storm_counts.rb

@@ -8,7 +8,8 @@ module RailsErrorDashboard
     # Runs in a background job (DB allowed). For each counted fingerprint:
     #   1. Recompute the canonical error_hash from the stored identity parts
     #      (the gate's key deliberately omits application_id — resolved here)
-    #   2. Unresolved match  → single UPDATE: occurrence_count += N
+    #   2. Unresolved match  → the ONE row FindOrIncrementError would pick
+    #      (24 h window, exact environment first): occurrence_count += N
     #   3. Resolved match    → reopen (mirrors FindOrIncrementError semantics)
     #   4. No match          → create a minimal ErrorLog from the exemplar
     #
@@ -59,26 +60,33 @@ module RailsErrorDashboard
 
         error_hash = canonical_hash(entry, application)
         last_seen = parse_time(entry["last_seen_at"]) || Time.current
-        env = current_environment
-
-        # Priority 1: unresolved match — one UPDATE, no row instantiation.
-        # Environment mirrors FindOrIncrementError: exact row first, then a
-        # legacy NULL row which is stamped as it is claimed. Two statements
-        # rather than one IN (env, NULL), because update_all would hit BOTH
-        # rows when they coexist and double-count.
-        unresolved = ErrorLog.unresolved.where(error_hash: error_hash, application_id: application.id)
-        if env
-          updated = unresolved.where(environment: env)
-            .update_all([ "occurrence_count = occurrence_count + ?, last_seen_at = ?", count, last_seen ])
-          return count if updated.positive?
-
-          updated = unresolved.where(environment: nil)
-            .update_all([ "occurrence_count = occurrence_count + ?, last_seen_at = ?, environment = ?",
-                          count, last_seen, env ])
-          return count if updated.positive?
-        else
-          updated = unresolved.update_all([ "occurrence_count = occurrence_count + ?, last_seen_at = ?", count, last_seen ])
-          return count if updated.positive?
+        # An explicit environment captured at the gate wins over the worker's
+        # own, mirroring LogError#resolve_environment for full captures.
+        env = current_environment && (entry["environment"].presence || current_environment)
+
+        # Priority 1: unresolved match — ONE row, chosen exactly as
+        # FindOrIncrementError chooses it (same hash + application, occurred
+        # within 24 h, exact environment before a legacy NULL row, most
+        # recently seen first), then a single atomic UPDATE on that id.
+        #
+        # It must be one row: the normal path opens a fresh group once the
+        # previous one's occurred_at falls outside the 24 h window, so a
+        # long-running unresolved error legitimately owns several unresolved
+        # rows. An update_all across the whole hash would add N to every one
+        # of them — seven real events becoming twelve counted occurrences.
+        target = unresolved_target(error_hash, application, env)
+        if target
+          if env && target.environment.blank?
+            ErrorLog.where(id: target.id).update_all([
+              "occurrence_count = occurrence_count + ?, last_seen_at = ?, environment = ?",
+              count, last_seen, env
+            ])
+          else
+            ErrorLog.where(id: target.id).update_all([
+              "occurrence_count = occurrence_count + ?, last_seen_at = ?", count, last_seen
+            ])
+          end
+          return count
         end
 
         # Priority 2: resolved/wont_fix match — reopen, mirroring
@@ -107,12 +115,17 @@ module RailsErrorDashboard
 
         # Priority 3: first seen during count-only mode — minimal ErrorLog
         # from the exemplar (no backtrace/context was captured; the next
-        # occurrence after the storm fills in detail via the normal path)
+        # occurrence after the storm fills in detail via the normal path).
+        #
+        # The exemplar message is RAW — the gate stores what the exception
+        # said so the canonical hash (computed above, from the raw message,
+        # exactly as the full path does) still lands on the same row. It must
+        # therefore go through the same redaction as LogError before it is
+        # persisted; storm protection and sensitive filtering are both on by
+        # default, and an incident is exactly when a password in a message
+        # must not reach the database.
         create_attrs = {
-          environment: env
-        }.compact
-        ErrorLog.create!(
-          **create_attrs,
+          environment: env,
           application_id: application.id,
           error_type: entry["error_class"],
           message: entry["message"],
@@ -124,10 +137,32 @@ module RailsErrorDashboard
           occurrence_count: count,
           error_hash: error_hash,
           resolved: false
-        )
+        }.compact
+        ErrorLog.create!(**ErrorLog.clamp_string_attributes(Services::SensitiveDataFilter.filter_attributes(create_attrs)))
         count
       end
 
+
+      # The unresolved row the full capture path would increment right now.
+      def unresolved_target(error_hash, application, env)
+        scope = ErrorLog.unresolved
+          .where(error_hash: error_hash, application_id: application.id)
+          .where("occurred_at >= ?", 24.hours.ago)
+        if env
+          scope = scope.where(environment: [ env, nil ])
+            .order(Arel.sql("CASE WHEN environment IS NULL THEN 1 ELSE 0 END"))
+        end
+        scope.order(last_seen_at: :desc).select(:id, :environment).first
+      end
+
+      # The redaction LogError applies to a message, for exemplars that reach
+      # the database by any other route (first-seen rows, the storm ledger).
+      def redact_message(message)
+        return message if message.blank?
+
+        Services::SensitiveDataFilter.filter_attributes({ message: message.to_s })[:message]
+      end
+
       # Mirrors ErrorHashGenerator.call exactly: same fields, same order,
       # same normalization — so counts land on the same ErrorLog the full
       # capture path would have used.
@@ -196,7 +231,7 @@ module RailsErrorDashboard
         existing = event.top_fingerprints_list
         fresh = @entries.map { |e|
           e = e.with_indifferent_access if e.respond_to?(:with_indifferent_access)
-          { "class" => e["error_class"], "message" => e["message"].to_s[0, 120], "count" => e["count"].to_i }
+          { "class" => e["error_class"], "message" => redact_message(e["message"]).to_s[0, 120], "count" => e["count"].to_i }
         }
 
         merged = (existing + fresh)

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -299,6 +299,9 @@ module RailsErrorDashboard
         # Apply sensitive data filtering (on by default)
         attributes = Services::SensitiveDataFilter.filter_attributes(attributes)
 
+        # Fit string metadata to its columns (after hashing, before writing)
+        attributes = ErrorLog.clamp_string_attributes(attributes)
+
         # Harvest breadcrumbs (if enabled and column exists)
         if !storm_lite && ErrorLog.column_names.include?("breadcrumbs") && RailsErrorDashboard.configuration.enable_breadcrumbs
           # Sync path: harvest from current thread
@@ -377,13 +380,19 @@ module RailsErrorDashboard
         #  Track individual error occurrence for co-occurrence analysis (if table exists)
         if defined?(ErrorOccurrence) && ErrorOccurrence.table_exists?
           begin
-            ErrorOccurrence.create(
+            occurrence_attrs = {
               error_log: error_log,
               occurred_at: attributes[:occurred_at],
               user_id: attributes[:user_id],
               request_id: error_context.request_id,
               session_id: error_context.session_id
-            )
+            }
+            # The release THIS event happened under. The group keeps its first
+            # release; per-release counts come from here (ReleaseTimeline).
+            occurrence_columns = ErrorOccurrence.column_names
+            occurrence_attrs[:app_version] = attributes[:app_version] if occurrence_columns.include?("app_version")
+            occurrence_attrs[:git_sha] = attributes[:git_sha] if occurrence_columns.include?("git_sha")
+            ErrorOccurrence.create(ErrorOccurrence.clamp_string_attributes(occurrence_attrs))
           rescue => e
             RailsErrorDashboard::Logger.error("Failed to create error occurrence: #{e.message}")
           end

data/lib/rails_error_dashboard/configuration.rb

@@ -169,6 +169,8 @@ module RailsErrorDashboard
 
     # System health snapshot (GC, memory, threads, connection pool at error time)
     attr_accessor :enable_system_health            # Master switch (default: false)
+    attr_accessor :system_health_queue_stats       # Include job-queue depth counts (default: true)
+    attr_accessor :system_health_queue_stats_cache_seconds # Reuse queue counts this long per process (default: 10)
 
     # Local variable capture via TracePoint(:raise)
     attr_accessor :enable_local_variables            # Master switch (default: false)
@@ -393,6 +395,11 @@ module RailsErrorDashboard
 
       # System health snapshot defaults - OFF by default (opt-in)
       @enable_system_health = false  # Capture GC, memory, threads, connection pool at error time
+      # Queue-depth counts are queries against the queue store (five COUNTs
+      # for Solid Queue), the one part of the snapshot that is not sub-ms.
+      # Cached per process so an error burst runs them once per interval.
+      @system_health_queue_stats = true
+      @system_health_queue_stats_cache_seconds = 10
 
       # Local variable capture defaults - OFF by default (opt-in)
       @enable_local_variables = false           # TracePoint(:raise) for local var capture

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -126,7 +126,10 @@ module RailsErrorDashboard
         total = error_statistics[:total]
         return 0 if total.zero?
 
-        resolved_count = ErrorLog.resolved.where("occurred_at >= ?", @start_date).count
+        # Same scoped relation as the denominator: an unscoped numerator
+        # counted every application's resolved errors against one
+        # application's total, and the "rate" went past 100%.
+        resolved_count = base_query.resolved.count
         ((resolved_count.to_f / total) * 100).round(1)
       end