rails_error_dashboard 0.14.4 → 0.16.0

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

data/app/jobs/rails_error_dashboard/pagerduty_error_notification_job.rb

@@ -44,7 +44,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/retention_cleanup_job.rb

@@ -44,6 +44,11 @@ module RailsErrorDashboard
     def self.delete_with_dependents(scope)
       ids = scope.select(:id)
 
+      # Each occurrence's stored context. Named here for the same reason as the
+      # event counts below: delete_all fires no :dependent callback.
+      if ErrorOccurrenceContext.table_exists?
+        ErrorOccurrenceContext.where(error_log_id: ids).in_batches(of: 1000).delete_all
+      end
       ErrorOccurrence.where(error_log_id: ids).in_batches(of: 1000).delete_all
       # Hour buckets for storm-shed events. Listed explicitly because delete_all
       # does not fire the has_many :dependent callback on ErrorLog -- without
@@ -70,6 +75,7 @@ module RailsErrorDashboard
       # errors — clean them up BEFORE the early return below, which fires
       # whenever no error logs happen to be expired.
       cleanup_rack_attack_events(cutoff)
+      cleanup_missing_translations(cutoff)
       cleanup_storm_flush_batches(cutoff)
       cleanup_diagnostic_dumps(cutoff)
       cleanup_swallowed_exceptions(cutoff)
@@ -211,6 +217,31 @@ module RailsErrorDashboard
       )
     end
 
+    # Expire missing-translation rows not seen since the cutoff. A key that
+    # is still missing is still being seen, so it keeps its row (and its
+    # first_seen_at); only keys that stopped missing age out.
+    #
+    # Not gated on the feature flag: rows collected while tracking was on
+    # must still age out after it is turned off.
+    def cleanup_missing_translations(cutoff)
+      return unless MissingTranslation.table_exists?
+
+      deleted = 0
+      MissingTranslation.where("last_seen_at < ?", cutoff).in_batches(of: 1000) do |batch|
+        deleted += batch.delete_all
+      end
+
+      if deleted > 0
+        RailsErrorDashboard::Logger.info(
+          "[RailsErrorDashboard] Retention cleanup: deleted #{deleted} missing translations"
+        )
+      end
+    rescue => e
+      RailsErrorDashboard::Logger.debug(
+        "[RailsErrorDashboard] Missing translation retention cleanup failed: #{e.class} - #{e.message}"
+      )
+    end
+
     # Expire aggregated Rack Attack event rows. Isolated in its own rescue so a
     # failure here (e.g. table not yet migrated) never blocks error cleanup.
     def cleanup_rack_attack_events(cutoff)

data/app/jobs/rails_error_dashboard/scheduled_digest_job.rb

@@ -12,11 +12,16 @@ module RailsErrorDashboard
   class ScheduledDigestJob < ApplicationJob
     queue_as :default
 
+    # @param period [String, Symbol, nil] "daily" or "weekly"; nil takes
+    #   config.digest_frequency, which was shown on the Settings page but
+    #   read by nothing until now.
     # @param locale [String, nil] resolved at enqueue time. nil for jobs
     #   enqueued by a pre-Phase-4 version still draining from the queue.
-    def perform(period: "daily", application_id: nil, locale: nil)
+    def perform(period: nil, application_id: nil, locale: nil)
       return unless RailsErrorDashboard.configuration.enable_scheduled_digests
 
+      period ||= RailsErrorDashboard.configuration.digest_frequency || :daily
+
       recipients = effective_recipients
       return if recipients.blank?
 

data/app/jobs/rails_error_dashboard/slack_error_notification_job.rb

@@ -32,7 +32,7 @@ module RailsErrorDashboard
       http.open_timeout = 5  # 5 seconds to establish connection
       http.read_timeout = 10  # 10 seconds to read response
 
-      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 = Services::SlackPayloadBuilder.call(error_log, locale: locale).to_json
 
       response = http.request(request)

data/app/jobs/rails_error_dashboard/telegram_error_notification_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Job to send error notifications to a Telegram chat via the Bot API
+  class TelegramErrorNotificationJob < ApplicationJob
+    queue_as :default
+
+    # @param locale [String, nil] resolved at enqueue time.
+    def perform(error_log_id, locale = nil)
+      return unless Services::TelegramDelivery.credentials?
+
+      error_log = ErrorLog.find(error_log_id)
+      payload = Services::TelegramPayloadBuilder.call(error_log, locale: job_locale(locale))
+
+      Services::TelegramDelivery.post(payload)
+    rescue StandardError => e
+      # The bot token is in the request URL; an exception that quotes it must
+      # not reach the log as-is.
+      Rails.logger.error(
+        "[RailsErrorDashboard] Failed to send Telegram notification: #{Services::TelegramDelivery.redact(e.message)}"
+      )
+      Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace
+    end
+  end
+end

data/app/jobs/rails_error_dashboard/webhook_error_notification_job.rb

@@ -31,13 +31,12 @@ module RailsErrorDashboard
 
     def send_webhook(url, payload, error_log)
       headers = {
-        "Content-Type" => "application/json",
-        "User-Agent" => "RailsErrorDashboard/1.0",
         "X-Error-Dashboard-Event" => "error.created",
         "X-Error-Dashboard-ID" => error_log.id.to_s
       }
 
-      response = post_json(url, payload, headers)
+      # Serialises, signs (when webhook_signing_secret is set) and posts.
+      response = Services::WebhookDelivery.post(url, payload, headers: headers)
 
       unless response_success?(response)
         Rails.logger.warn("[RailsErrorDashboard] Webhook failed for #{url}: #{response_code(response)}")
@@ -46,21 +45,6 @@ module RailsErrorDashboard
       Rails.logger.error("[RailsErrorDashboard] Webhook error for #{url}: #{e.message}")
     end
 
-    def post_json(url, payload, headers)
-      if defined?(HTTParty)
-        HTTParty.post(url, body: payload.to_json, headers: headers, timeout: 10)
-      else
-        uri = URI(url)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == "https"
-        http.open_timeout = 5
-        http.read_timeout = 10
-        request = Net::HTTP::Post.new(uri.path, headers)
-        request.body = payload.to_json
-        http.request(request)
-      end
-    end
-
     def response_success?(response)
       if response.respond_to?(:success?)
         response.success?

data/app/models/rails_error_dashboard/error_log.rb

@@ -36,6 +36,8 @@ module RailsErrorDashboard
 
     # Association for tracking individual error occurrences
     has_many :error_occurrences, class_name: "RailsErrorDashboard::ErrorOccurrence", dependent: :destroy
+    # Deleted before the occurrences, without loading their payloads
+    has_many :occurrence_contexts, class_name: "RailsErrorDashboard::ErrorOccurrenceContext", dependent: :delete_all
 
     # Hour buckets for storm-shed events. delete_all, not destroy: these rows
     # are pure counters with no callbacks, and a group can own one per hour.
@@ -179,6 +181,14 @@ module RailsErrorDashboard
       Services::SeverityClassifier.critical?(error_type)
     end
 
+    # Whether the backtrace this row shows was sent by a client through
+    # ManualErrorReporter. Its frames describe code that ran on the client, so
+    # View Source, git blame and the Markdown formatter read no file for them.
+    # nil (a row from before the column, or an app not yet migrated) is server.
+    def client_backtrace?
+      has_attribute?(:backtrace_source) && backtrace_source == "client"
+    end
+
     # Check if error is recent (< 1 hour)
     def recent?
       occurred_at >= 1.hour.ago
@@ -204,6 +214,13 @@ module RailsErrorDashboard
       Commands::LogError.call(exception, context)
     end
 
+    # nil rather than a wrong user: an integer column casts "3f2a9c1e-..." to 3
+    def self.storable_user_id(user_id)
+      return user_id unless type_for_attribute("user_id").type == :integer
+
+      Integer(user_id.to_s, 10, exception: false)
+    end
+
     # Mark error as resolved (delegates to Command)
     def resolve!(resolution_data = {})
       Commands::ResolveError.call(id, resolution_data)
@@ -332,14 +349,7 @@ module RailsErrorDashboard
         []
       end
 
-      lines.first(20).map do |line|
-        # Extract file path and method name, ignore line numbers
-        if line =~ %r{([^/]+\.rb):.*?in `(.+)'$}
-          "#{Regexp.last_match(1)}:#{Regexp.last_match(2)}"
-        elsif line =~ %r{([^/]+\.rb)}
-          Regexp.last_match(1)
-        end
-      end.compact.uniq
+      lines.first(20).map { |line| Services::BacktraceProcessor.frame_key(line) }.compact.uniq
     end
 
     # Calculate backtrace signature — delegates to Service
@@ -415,13 +425,8 @@ module RailsErrorDashboard
       return {} unless RailsErrorDashboard.configuration.enable_occurrence_patterns
       return {} unless defined?(Services::PatternDetector)
 
-      timestamps = self.class
-        .where(error_type: error_type, platform: platform)
-        .where("occurred_at >= ?", days.days.ago)
-        .pluck(:occurred_at)
-
       Services::PatternDetector.analyze_cyclical_pattern(
-        timestamps: timestamps,
+        timestamps: pattern_timestamps(days: days),
         days: days
       )
     end
@@ -433,13 +438,42 @@ module RailsErrorDashboard
       return [] unless RailsErrorDashboard.configuration.enable_occurrence_patterns
       return [] unless defined?(Services::PatternDetector)
 
-      timestamps = self.class
-        .where(error_type: error_type, platform: platform)
-        .where("occurred_at >= ?", days.days.ago)
-        .order(:occurred_at)
-        .pluck(:occurred_at)
+      Services::PatternDetector.detect_bursts(timestamps: pattern_timestamps(days: days))
+    end
+
+    # The most recent occurrence timestamps a Pattern Insights sample reads.
+    # A grouped row holds one occurred_at for hundreds of events, so the
+    # pattern used to be computed from one timestamp per error: the per-event
+    # rows are what a daily or weekly rhythm is visible in. Capped so an error
+    # with a million occurrences does not load a million Time objects to
+    # bucket them by hour; the newest PATTERN_SAMPLE_LIMIT are enough for a
+    # distribution and for the bursts of the last week.
+    PATTERN_SAMPLE_LIMIT = 10_000
+
+    def pattern_timestamps(days:)
+      since = days.days.ago
+      grouped = self.class.where(error_type: error_type, platform: platform)
+
+      if occurrence_rows_available?
+        timestamps = ErrorOccurrence.where(error_log_id: grouped.select(:id))
+                                    .where("occurred_at >= ?", since)
+                                    .order(occurred_at: :desc)
+                                    .limit(PATTERN_SAMPLE_LIMIT)
+                                    .pluck(:occurred_at)
+                                    .reverse
+        return timestamps if timestamps.any?
+      end
 
-      Services::PatternDetector.detect_bursts(timestamps: timestamps)
+      # No per-event rows: an install from before the occurrences table, or
+      # rows captured while a storm was being shed. The grouped rows are the
+      # only timestamps there are.
+      grouped.where("occurred_at >= ?", since).order(:occurred_at).pluck(:occurred_at)
+    end
+
+    def occurrence_rows_available?
+      defined?(ErrorOccurrence) && ErrorOccurrence.table_exists?
+    rescue StandardError
+      false
     end
 
     private

data/app/models/rails_error_dashboard/error_occurrence.rb

@@ -10,6 +10,7 @@ module RailsErrorDashboard
     self.table_name = "rails_error_dashboard_error_occurrences"
 
     belongs_to :error_log, class_name: "RailsErrorDashboard::ErrorLog"
+    has_one :context, class_name: "RailsErrorDashboard::ErrorOccurrenceContext", dependent: :delete
 
     # Only define user association if User model exists
     if defined?(::User)

data/app/models/rails_error_dashboard/error_occurrence_context.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # The moment-of-failure context of one occurrence: breadcrumbs, system
+  # health, local and instance variables, the same JSON strings the error row
+  # holds for its latest capture. Commands::RecordOccurrenceContext writes them
+  # and keeps the newest config.occurrence_context_limit per error.
+  class ErrorOccurrenceContext < ErrorLogsRecord
+    self.table_name = "rails_error_dashboard_error_occurrence_contexts"
+
+    belongs_to :error_occurrence, class_name: "RailsErrorDashboard::ErrorOccurrence"
+    belongs_to :error_log, class_name: "RailsErrorDashboard::ErrorLog"
+  end
+end

data/app/models/rails_error_dashboard/missing_translation.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # A translation key the host app looked up and did not have, counted per
+  # (locale, key, application).
+  #
+  # Rows are written by Commands::FlushMissingTranslations from the tracker's
+  # in-memory buffer, never one per lookup. Inherits ErrorLogsRecord so
+  # separate-database routing applies.
+  class MissingTranslation < ErrorLogsRecord
+    self.table_name = "rails_error_dashboard_missing_translations"
+
+    # Not a translation key: a synthetic row holding the misses the tracker
+    # dropped because its per-thread buffer was full, kept so the totals the
+    # dashboard shows are never silently understated. Stored under a locale
+    # no real lookup uses. The tracker owns the values; aliased here so the
+    # writer and the scopes below cannot drift apart.
+    OVERFLOW_KEY = Services::MissingTranslationTracker::OVERFLOW_KEY
+    OVERFLOW_LOCALE = Services::MissingTranslationTracker::OVERFLOW_LOCALE
+
+    belongs_to :application, optional: true
+
+    validates :locale, presence: true
+    validates :translation_key, presence: true
+    validates :miss_count, presence: true, numericality: { greater_than_or_equal_to: 0 }
+
+    scope :for_application, ->(app_id) { where(application_id: app_id) }
+    scope :seen_since, ->(time) { where("last_seen_at >= ?", time) }
+    scope :overflow, -> { where(translation_key: OVERFLOW_KEY) }
+    scope :real, -> { where.not(translation_key: OVERFLOW_KEY) }
+
+    # The table may not be migrated yet on a host that upgraded the gem before
+    # running the migration. Everything that touches this model on a request
+    # path checks first and must never raise.
+    def self.table_exists?
+      connection.table_exists?(table_name)
+    rescue *Commands::LogError::RETRYABLE_STORE_ERRORS
+      raise
+    rescue StandardError
+      false
+    end
+  end
+end

data/app/views/layouts/rails_error_dashboard.html.erb

@@ -1156,6 +1156,12 @@ tr[data-red-row-href]:hover .sev-bar { opacity: 1 !important; }
           <% if RailsErrorDashboard.configuration.enable_storm_protection %>
             <% diag_items << { path: storms_errors_path(nav_params), icon: 'bi-cloud-lightning-rain', label: red_t("red.nav.storms") } %>
           <% end %>
+          <% if RailsErrorDashboard.configuration.enable_missing_translation_tracking %>
+            <% diag_items << { path: missing_translations_errors_path(nav_params), icon: 'bi-translate', label: red_t("red.nav.missing_translations") } %>
+          <% end %>
+          <% if RailsErrorDashboard.configuration.enable_crash_capture %>
+            <% diag_items << { path: boot_errors_errors_path(nav_params), icon: 'bi-power', label: red_t("red.nav.boot_errors") } %>
+          <% end %>
 
           <% if diag_items.any? %>
             <div style="margin-bottom: var(--space-2);" id="navDiagSection">
@@ -1552,7 +1558,11 @@ tr[data-red-row-href]:hover .sev-bar { opacity: 1 !important; }
     });
 
     if (typeof hljs.lineNumbersBlock === 'function') {
-      codeBlocks.forEach(function(block) { hljs.lineNumbersBlock(block); });
+      // The gutter shows the file's own line numbers: the excerpt starts at
+      // data-start-line, not at 1.
+      codeBlocks.forEach(function(block) {
+        hljs.lineNumbersBlock(block, { startFrom: parseInt(block.dataset.startLine) || 1 });
+      });
     } else if (typeof hljs.initLineNumbersOnLoad === 'function') {
       hljs.initLineNumbersOnLoad();
     }
@@ -2504,7 +2514,9 @@ document.addEventListener('DOMContentLoaded', function() {
       case 'toggle-next':
         var nextEl = actionEl.nextElementSibling;
         if (nextEl) {
-          var isHidden = nextEl.style.display === 'none' || nextEl.style.display === '';
+          // The computed display: an open element usually has no inline display
+          // at all, and reading '' as hidden made the first click a no-op.
+          var isHidden = window.getComputedStyle(nextEl).display === 'none';
           nextEl.style.display = isHidden ? (actionEl.dataset.redDisplay || 'block') : 'none';
           var chev = actionEl.querySelector('.chev');
           if (chev) {

data/app/views/rails_error_dashboard/errors/_captured_occurrences.html.erb

@@ -0,0 +1,45 @@
+      <!-- Captured occurrences: the ones whose context is still stored -->
+      <% if occurrences.any? %>
+        <div class="card mb-4" id="section-captured-occurrences">
+          <div class="card-header">
+            <h5 class="mb-0">
+              <i class="bi bi-camera"></i> <%= red_t("red.errors.captured_occurrences.title") %>
+            </h5>
+            <small class="text-muted"><%= red_t("red.errors.captured_occurrences.hint") %></small>
+          </div>
+          <div class="card-body p-0">
+            <div class="table-responsive">
+              <table class="table table-hover mb-0">
+                <thead class="table-light">
+                  <tr>
+                    <th><%= red_t("red.errors.captured_occurrences.column_occurrence") %></th>
+                    <th><%= red_t("red.errors.captured_occurrences.column_occurred_at") %></th>
+                    <th><%= red_t("red.errors.captured_occurrences.column_version") %></th>
+                    <th></th>
+                  </tr>
+                </thead>
+                <tbody>
+                  <% occurrences.each do |occurrence| %>
+                    <tr>
+                      <td>
+                        <code>#<%= occurrence.id %></code>
+                        <% if occurrence.id == current_id %>
+                          <span class="badge bg-info text-dark ms-1"><%= red_t("red.errors.captured_occurrences.viewing") %></span>
+                        <% end %>
+                      </td>
+                      <td><%= local_time(occurrence.occurred_at) %></td>
+                      <td>
+                        <% version = occurrence.app_version.presence || occurrence.git_sha.to_s.first(7).presence %>
+                        <small class="text-muted"><%= version || red_t("red.common.not_available") %></small>
+                      </td>
+                      <td class="text-end">
+                        <%= link_to red_t("red.errors.captured_occurrences.view"), error_path(error, occurrence: occurrence.id, **app_context), class: "btn btn-sm btn-outline-primary" %>
+                      </td>
+                    </tr>
+                  <% end %>
+                </tbody>
+              </table>
+            </div>
+          </div>
+        </div>
+      <% end %>

data/app/views/rails_error_dashboard/errors/_error_info.html.erb

@@ -1,7 +1,9 @@
       <%# The locale is part of the cache key: this fragment now contains
           translated text, and without it the first locale to render an error
           would be served to every other one. %>
-      <% cache [error, 'error_details_v2', red_locale] do %>
+      <%# Plus the source-integration configuration and a TTL, and not at all
+          while coverage is live: see BacktraceHelper#source_view_cache_key. %>
+      <% cache_if source_view_cacheable?, [error, 'error_details_v3', red_locale, source_view_cache_key, error.client_backtrace?], **source_view_cache_options do %>
       <div class="card mb-4" id="section-error-info">
         <div class="card-header bg-danger text-white">
           <div class="d-flex justify-content-between align-items-center">
@@ -106,6 +108,8 @@
           <% if error.backtrace.present? %>
             <% frames = parse_backtrace(error.backtrace) %>
             <% app_frames = filter_app_code(frames) %>
+            <%# A client's frames describe code that ran on the client: no file is read for them %>
+            <% source_viewable = RailsErrorDashboard.configuration.enable_source_code_integration && !error.client_backtrace? %>
             <% framework_frames = filter_framework_code(frames) %>
 
             <% if app_frames.any? %>
@@ -120,6 +124,11 @@
                   </div>
                 </div>
                 <div class="card-body p-0">
+                  <% if RailsErrorDashboard.configuration.enable_source_code_integration && error.client_backtrace? %>
+                    <div class="alert alert-info m-3 mb-0" id="client-backtrace-note" style="font-size: 12px;">
+                      <i class="bi bi-phone"></i> <%= red_t("red.errors.info.backtrace.client_report_note") %>
+                    </div>
+                  <% end %>
                   <div class="code-block p-3" style="max-height: none; overflow-y: visible; overflow-x: auto;">
                     <% app_frames.each_with_index do |frame, index| %>
                       <div class="backtrace-frame-wrapper mb-2">
@@ -131,7 +140,7 @@
                               <%= frame_icon(frame[:category]) %> <%= frame[:short_path] %>:<%= frame[:line_number] %>
                             </span> in <span class="backtrace-method-name">`<%= frame[:method_name] %>'</span>
                           </div>
-                          <% if RailsErrorDashboard.configuration.enable_source_code_integration && frame[:category] == :app %>
+                          <% if source_viewable && frame[:category] == :app %>
                             <button class="btn btn-sm btn-outline-secondary" type="button"
                                     data-bs-toggle="collapse"
                                     data-bs-target="#source-code-<%= index %>"
@@ -143,7 +152,7 @@
                         </div>
 
                         <!-- Collapsible source code (only for app frames) -->
-                        <% if RailsErrorDashboard.configuration.enable_source_code_integration && frame[:category] == :app %>
+                        <% if source_viewable && frame[:category] == :app %>
                           <div class="collapse" id="source-code-<%= index %>">
                             <%= render "source_code", frame: frame, error: error, index: index %>
                           </div>

data/app/views/rails_error_dashboard/errors/_occurrence_banner.html.erb

@@ -0,0 +1,12 @@
+<% if occurrence_context %>
+  <%# Only the context cards follow ?occurrence=; the rest of the page is the error row's latest capture %>
+  <div class="alert alert-info mb-3" id="occurrence-banner" style="display: flex; justify-content: space-between; align-items: center; gap: var(--space-3); padding: var(--space-3) var(--space-4);">
+    <div style="font-size: 12px;">
+      <i class="bi bi-clock-history"></i>
+      <strong><%= red_t("red.errors.show.occurrence.title", id: occurrence_context.error_occurrence_id) %></strong>
+      &middot; <%= local_time(occurrence_context.error_occurrence&.occurred_at || occurrence_context.created_at) %>
+      <div><%= red_t("red.errors.show.occurrence.body") %></div>
+    </div>
+    <%= link_to red_t("red.errors.show.occurrence.show_latest"), error_path(error, **app_context), class: "btn btn-sm" %>
+  </div>
+<% end %>

data/app/views/rails_error_dashboard/errors/_sidebar_metadata.html.erb

@@ -187,8 +187,10 @@
                         </small>
                       <% end %>
                     </div>
+                    <%# data-red-action, not data-turbo-confirm: the layout runs with
+                        Turbo off and loads no UJS, so nothing read the old attribute. %>
                     <%= button_to unassign_error_path(error), method: :post, class: "btn btn-sm btn-outline-secondary",
-                        data: { turbo_confirm: red_t("red.errors.sidebar.remove_assignment") } do %>
+                        form: { data: { red_action: "confirm-submit", red_confirm_message: red_t("red.errors.sidebar.remove_assignment") } } do %>
                       <i class="bi bi-x"></i>
                     <% end %>
                   </div>

data/app/views/rails_error_dashboard/errors/_source_code.html.erb

@@ -20,17 +20,11 @@
           </div>
 
           <% if repo_link %>
-            <%
-              # Repository host names are brands and stay English; only the
-              # sentence around the name is translated.
-              repo_host = if repo_link.include?("github") then "GitHub"
-              elsif repo_link.include?("gitlab") then "GitLab"
-              else "Bitbucket"
-              end
-            %>
+            <%# Repository host names are brands and stay English; only the
+                sentence around the name is translated. %>
             <%= link_to repo_link, target: "_blank", rel: "noopener",
                 class: "btn btn-sm btn-primary",
-                title: red_t("red.errors.source_code.view_on", host: repo_host) do %>
+                title: red_t("red.errors.source_code.view_on", host: repository_host_label(repo_link)) do %>
               <i class="bi bi-box-arrow-up-right"></i> <%= red_t("red.errors.source_code.view_source") %>
             <% end %>
           <% end %>

data/app/views/rails_error_dashboard/errors/activestorage_health_summary.html.erb

@@ -20,6 +20,34 @@
     </div>
   </div>
 
+  <% probe = @storage_probe || {} %>
+  <% if probe[:status] && probe[:status] != "skipped" %>
+    <% reachable = probe[:status] == "ok" %>
+    <div class="card mb-4 border-<%= reachable ? "success" : "danger" %>">
+      <div class="card-body d-flex justify-content-between align-items-center flex-wrap gap-2">
+        <div>
+          <h6 class="mb-1">
+            <i class="bi <%= reachable ? "bi-check-circle-fill text-success" : "bi-x-circle-fill text-danger" %> me-1"></i>
+            <%= red_t("red.health.activestorage.probe.title") %>
+            <span class="badge <%= reachable ? "bg-success" : "bg-danger" %> ms-1">
+              <%= reachable ? red_t("red.health.activestorage.probe.reachable") : red_t("red.health.activestorage.probe.unreachable") %>
+            </span>
+          </h6>
+          <small class="text-muted">
+            <%# The service name comes from config/storage.yml and the error is an exception class: machine values, shown as-is. %>
+            <%= red_t("red.health.activestorage.probe.service", name: probe[:service].presence || "?") %>
+            <% if reachable %>
+              &middot; <%= red_t("red.health.activestorage.probe.latency", ms: probe[:latency_ms]) %>
+            <% else %>
+              &middot; <code><%= probe[:error] %></code>
+            <% end %>
+          </small>
+        </div>
+        <small class="text-muted"><%= red_t("red.health.activestorage.probe.how") %></small>
+      </div>
+    </div>
+  <% end %>
+
   <% if @unique_services == 0 %>
     <div class="red-empty-state">
       <i class="bi bi-cloud-arrow-up display-1 text-success mb-3"></i>