rails_error_dashboard 0.14.4 → 0.16.0

data/lib/generators/rails_error_dashboard/install/install_generator.rb

@@ -12,6 +12,7 @@ module RailsErrorDashboard
       class_option :slack, type: :boolean, default: false, desc: "Enable Slack notifications"
       class_option :email, type: :boolean, default: false, desc: "Enable email notifications"
       class_option :discord, type: :boolean, default: false, desc: "Enable Discord notifications"
+      class_option :telegram, type: :boolean, default: false, desc: "Enable Telegram notifications"
       class_option :pagerduty, type: :boolean, default: false, desc: "Enable PagerDuty notifications"
       class_option :webhooks, type: :boolean, default: false, desc: "Enable webhook notifications"
       # Performance options
@@ -71,13 +72,13 @@ module RailsErrorDashboard
         @selected_features = {}
 
         # =====================================================================
-        # QUESTION 1: Notifications (gated — one y/N opens 5 sub-questions)
+        # QUESTION 1: Notifications (gated — one y/N opens 6 sub-questions)
         # =====================================================================
-        notification_keys = %i[slack email discord pagerduty webhooks]
+        notification_keys = %i[slack email discord telegram pagerduty webhooks]
         any_notification_cli_flag = notification_keys.any? { |k| options[k] }
 
         say "[1/3] Notifications [background/dashboard only — zero request overhead]", :cyan
-        say "    Alert your team via Slack, email, Discord, PagerDuty, or webhooks.", :white
+        say "    Alert your team via Slack, email, Discord, Telegram, PagerDuty, or webhooks.", :white
 
         if any_notification_cli_flag
           # Individual CLI flags passed — respect them, skip the gate prompt
@@ -90,6 +91,7 @@ module RailsErrorDashboard
               { key: :slack,      name: "Slack",     hint: "SLACK_WEBHOOK_URL" },
               { key: :email,      name: "Email",     hint: "ERROR_NOTIFICATION_EMAILS" },
               { key: :discord,    name: "Discord",   hint: "DISCORD_WEBHOOK_URL" },
+              { key: :telegram,   name: "Telegram",  hint: "TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID" },
               { key: :pagerduty,  name: "PagerDuty", hint: "PAGERDUTY_INTEGRATION_KEY" },
               { key: :webhooks,   name: "Webhooks",  hint: "WEBHOOK_URLS" }
             ]
@@ -294,6 +296,7 @@ module RailsErrorDashboard
         @enable_slack = @selected_features&.dig(:slack) || options[:slack]
         @enable_email = @selected_features&.dig(:email) || options[:email]
         @enable_discord = @selected_features&.dig(:discord) || options[:discord]
+        @enable_telegram = @selected_features&.dig(:telegram) || options[:telegram]
         @enable_pagerduty = @selected_features&.dig(:pagerduty) || options[:pagerduty]
         @enable_webhooks = @selected_features&.dig(:webhooks) || options[:webhooks]
 
@@ -417,6 +420,7 @@ module RailsErrorDashboard
         notification_features << "Slack" if @enable_slack
         notification_features << "Email" if @enable_email
         notification_features << "Discord" if @enable_discord
+        notification_features << "Telegram" if @enable_telegram
         notification_features << "PagerDuty" if @enable_pagerduty
         notification_features << "Webhooks" if @enable_webhooks
 
@@ -481,6 +485,7 @@ module RailsErrorDashboard
         say "  → Set SLACK_WEBHOOK_URL in .env", :yellow if @enable_slack
         say "  → Set ERROR_NOTIFICATION_EMAILS in .env", :yellow if @enable_email
         say "  → Set DISCORD_WEBHOOK_URL in .env", :yellow if @enable_discord
+        say "  → Set TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID in .env", :yellow if @enable_telegram
         say "  → Set PAGERDUTY_INTEGRATION_KEY in .env", :yellow if @enable_pagerduty
         say "  → Set WEBHOOK_URLS in .env", :yellow if @enable_webhooks
         if @enable_async_logging
@@ -569,7 +574,7 @@ module RailsErrorDashboard
           system_health: true,     # ~1ms per error — GC, memory, threads at exact error moment
           error_sampling: true,    # 50% sampling on non-critical errors — halves storage, still shows patterns
           # OFF — require credentials, config, or niche use case
-          slack: false, email: false, discord: false, pagerduty: false, webhooks: false,
+          slack: false, email: false, discord: false, telegram: false, pagerduty: false, webhooks: false,
           source_code_integration: false,
           git_blame: false,
           swallowed_exceptions: false,

data/lib/generators/rails_error_dashboard/install/templates/initializer.rb

@@ -41,11 +41,14 @@ RailsErrorDashboard.configure do |config|
   # warden, session, request, params, cookies, redirect_to, etc.
   # Return truthy to allow access, falsy to deny (403 Forbidden).
   #
-  # NOTE: Devise helpers (current_user, authenticate_user!) are NOT available
-  # because the engine controller inherits from ActionController::Base, not your
-  # app's ApplicationController. Use `warden` directly instead.
-  #
-  # Devise/Warden example (recommended):
+  # Devise helpers (current_user, user_signed_in?, authenticate_user!) work:
+  # Devise adds them to ActionController::Base, which the engine's controller
+  # inherits. Methods defined only in your app's ApplicationController do not:
+  # the lambda raises and access is denied (logged as "authenticate_with lambda
+  # raised").
+  #
+  # Devise examples:
+  #   config.authenticate_with = -> { current_user&.admin? }
   #   config.authenticate_with = -> { warden.authenticated? }
   #
   # Warden with redirect to login:
@@ -127,6 +130,21 @@ RailsErrorDashboard.configure do |config|
   config.enable_discord_notifications = false
   # config.discord_webhook_url = ENV["DISCORD_WEBHOOK_URL"]
 
+<% end -%>
+<% if @enable_telegram -%>
+  # Telegram Notifications - ENABLED
+  config.enable_telegram_notifications = true
+  config.telegram_bot_token = ENV["TELEGRAM_BOT_TOKEN"]
+  config.telegram_chat_id = ENV["TELEGRAM_CHAT_ID"]
+  # To disable: Set config.enable_telegram_notifications = false
+
+<% else -%>
+  # Telegram Notifications - DISABLED
+  # To enable: Set config.enable_telegram_notifications = true and configure a bot token and chat id
+  config.enable_telegram_notifications = false
+  # config.telegram_bot_token = ENV["TELEGRAM_BOT_TOKEN"]
+  # config.telegram_chat_id = ENV["TELEGRAM_CHAT_ID"]
+
 <% end -%>
 <% if @enable_pagerduty -%>
   # PagerDuty Integration - ENABLED (critical errors only)
@@ -145,6 +163,9 @@ RailsErrorDashboard.configure do |config|
   # Generic Webhook Notifications - ENABLED
   config.enable_webhook_notifications = true
   config.webhook_urls = ENV.fetch("WEBHOOK_URLS", "").split(",").map(&:strip).reject(&:empty?)
+  # Sign every webhook (HMAC-SHA256 over timestamp + body) so receivers can
+  # verify it came from this app. Generate with: ruby -rsecurerandom -e 'puts SecureRandom.hex(32)'
+  # config.webhook_signing_secret = ENV["WEBHOOK_SIGNING_SECRET"]
   # To disable: Set config.enable_webhook_notifications = false
 
 <% else -%>
@@ -152,6 +173,7 @@ RailsErrorDashboard.configure do |config|
   # To enable: Set config.enable_webhook_notifications = true and configure webhook URLs
   config.enable_webhook_notifications = false
   # config.webhook_urls = ENV.fetch("WEBHOOK_URLS", "").split(",").map(&:strip).reject(&:empty?)
+  # config.webhook_signing_secret = ENV["WEBHOOK_SIGNING_SECRET"]  # HMAC-SHA256 signature headers
 
 <% end -%>
   # Dashboard base URL (used in notification links)
@@ -389,6 +411,12 @@ RailsErrorDashboard.configure do |config|
   config.enable_system_health = false
 
 <% end -%>
+  # Occurrence Context History (NEW in 0.16.0)
+  # Each occurrence keeps its own breadcrumbs, system health and variables, so
+  # any of an error's recent occurrences can be opened, not only the latest.
+  # Kept for the newest N occurrences per error; 0 stops storing them.
+  config.occurrence_context_limit = 25
+
 <% if @enable_swallowed_exceptions -%>
   # Swallowed Exception Detection - ENABLED
   # Requires Ruby 3.3+ — detects exceptions that are raised then silently rescued
@@ -408,6 +436,14 @@ RailsErrorDashboard.configure do |config|
   # config.swallowed_exception_threshold = 0.95
 
 <% end -%>
+  # Missing-Translation Tracking - DISABLED
+  # Counts every I18n key your app looked up and did not have, by locale, with
+  # the first call site, on its own dashboard page (/errors/missing_translations).
+  # Wraps I18n.exception_handler and delegates to the handler you already had —
+  # the one place RED touches global I18n state, which is why it is opt-in.
+  # To enable: Set config.enable_missing_translation_tracking = true
+  config.enable_missing_translation_tracking = false
+
 <% if @enable_diagnostic_dump -%>
   # Diagnostic Dump - ENABLED
   # On-demand system state snapshot via rake task or dashboard button

data/lib/rails_error_dashboard/commands/assign_error.rb

@@ -29,10 +29,33 @@ module RailsErrorDashboard
         error.update!(
           assigned_to: assignee.truncate(MAX_ASSIGNEE_LENGTH, omission: ""),
           assigned_at: Time.current,
-          status: "in_progress" # Auto-transition to in_progress when assigned
+          **status_attributes(error)
         )
+        # The stat cards are cached; a reopened error must show up at once.
+        Services::AnalyticsCacheManager.clear if error.saved_change_to_resolved?
+
         { success: true, error: error }
       end
+
+      private
+
+      # Assigning means someone is working on it, so the error moves to
+      # in_progress. Doing that to a resolved error used to leave
+      # resolved: true and resolved_at behind: a row that was in_progress to
+      # the eye, resolved to the scopes, and matched by neither the unresolved
+      # nor the resolved lookup, so its next recurrence opened a new row.
+      # Assigning a resolved error reopens it. wont_fix is sticky (H-6): the
+      # assignee is recorded and the status stays.
+      def status_attributes(error)
+        return {} if error.status == "wont_fix"
+
+        attrs = { status: "in_progress" }
+        if error.resolved? || error.status == "resolved"
+          attrs[:resolved] = false
+          attrs[:resolved_at] = nil
+        end
+        attrs
+      end
     end
   end
 end

data/lib/rails_error_dashboard/commands/batch_mute_errors.rb

@@ -23,6 +23,7 @@ module RailsErrorDashboard
 
         muted_count = 0
         failed_ids = []
+        failures = {}
         muted_errors = []
 
         errors.each do |error|
@@ -33,11 +34,18 @@ module RailsErrorDashboard
               muted_by: @muted_by,
               muted_reason: @reason
             )
+            # The comment a single mute writes, so the reason shows in the thread
+            if @reason.present?
+              error.comments.create!(author_name: @muted_by || "System", body: "Muted notifications: #{@reason}")
+            end
             muted_count += 1
             muted_errors << error
           rescue => e
             failed_ids << error.id
-            RailsErrorDashboard::Logger.error("Failed to mute error #{error.id}: #{e.message}")
+            failures[error.id] = "#{e.class}: #{e.message}"
+            # Rails.logger, not RED's logger: log_level defaults to :silent, and
+            # this is the only record of why the row failed
+            Rails.logger.warn("[RailsErrorDashboard] Failed to mute error #{error.id}: #{e.class}: #{e.message}")
           end
         end
 
@@ -50,7 +58,8 @@ module RailsErrorDashboard
           count: muted_count,
           total: @error_ids.size,
           failed_ids: failed_ids,
-          errors: failed_ids.empty? ? [] : [ red_tp("red.commands.batch_failed.mute", count: failed_ids.size) ]
+          failures: failures,
+          errors: failed_ids.empty? ? [] : [ "#{red_tp("red.commands.batch_failed.mute", count: failed_ids.size)} (#{failed_ids.map { |id| "##{id}" }.join(", ")})" ]
         }
       rescue => e
         RailsErrorDashboard::Logger.error("Batch mute failed: #{e.message}")

data/lib/rails_error_dashboard/commands/batch_resolve_errors.rb

@@ -24,6 +24,7 @@ module RailsErrorDashboard
 
         resolved_count = 0
         failed_ids = []
+        failures = {}
 
         resolved_errors = []
 
@@ -40,21 +41,33 @@ module RailsErrorDashboard
             resolved_errors << error
           rescue => e
             failed_ids << error.id
-            RailsErrorDashboard::Logger.error("Failed to resolve error #{error.id}: #{e.message}")
+            failures[error.id] = "#{e.class}: #{e.message}"
+            # Rails.logger, not RED's logger: log_level defaults to :silent, and
+            # this is the only record of why the row failed
+            Rails.logger.warn("[RailsErrorDashboard] Failed to resolve error #{error.id}: #{e.class}: #{e.message}")
           end
         end
 
-        # Dispatch plugin event for batch resolved errors
         Services::AnalyticsCacheManager.clear if resolved_count.positive?
 
+        # Dispatch plugin event for batch resolved errors
         PluginRegistry.dispatch(:on_errors_batch_resolved, resolved_errors) if resolved_errors.any?
 
+        # Each error resolved here is as resolved as one resolved on its own
+        # page: the host's error_resolved callbacks (the issue tracker closes
+        # the linked issue from one) and the instrumentation event fire per
+        # error. Only the plugin event is batch-shaped, by design.
+        resolved_errors.each do |error|
+          Services::ResolutionCallbacks.call(error, resolved_by: @resolved_by_name)
+        end
+
         {
           success: failed_ids.empty?,
           count: resolved_count,
           total: @error_ids.size,
           failed_ids: failed_ids,
-          errors: failed_ids.empty? ? [] : [ red_tp("red.commands.batch_failed.resolve", count: failed_ids.size) ]
+          failures: failures,
+          errors: failed_ids.empty? ? [] : [ "#{red_tp("red.commands.batch_failed.resolve", count: failed_ids.size)} (#{failed_ids.map { |id| "##{id}" }.join(", ")})" ]
         }
       rescue => e
         RailsErrorDashboard::Logger.error("Batch resolve failed: #{e.message}")

data/lib/rails_error_dashboard/commands/batch_unmute_errors.rb

@@ -21,6 +21,7 @@ module RailsErrorDashboard
 
         unmuted_count = 0
         failed_ids = []
+        failures = {}
         unmuted_errors = []
 
         errors.each do |error|
@@ -35,7 +36,10 @@ module RailsErrorDashboard
             unmuted_errors << error
           rescue => e
             failed_ids << error.id
-            RailsErrorDashboard::Logger.error("Failed to unmute error #{error.id}: #{e.message}")
+            failures[error.id] = "#{e.class}: #{e.message}"
+            # Rails.logger, not RED's logger: log_level defaults to :silent, and
+            # this is the only record of why the row failed
+            Rails.logger.warn("[RailsErrorDashboard] Failed to unmute error #{error.id}: #{e.class}: #{e.message}")
           end
         end
 
@@ -48,7 +52,8 @@ module RailsErrorDashboard
           count: unmuted_count,
           total: @error_ids.size,
           failed_ids: failed_ids,
-          errors: failed_ids.empty? ? [] : [ red_tp("red.commands.batch_failed.unmute", count: failed_ids.size) ]
+          failures: failures,
+          errors: failed_ids.empty? ? [] : [ "#{red_tp("red.commands.batch_failed.unmute", count: failed_ids.size)} (#{failed_ids.map { |id| "##{id}" }.join(", ")})" ]
         }
       rescue => e
         RailsErrorDashboard::Logger.error("Batch unmute failed: #{e.message}")

data/lib/rails_error_dashboard/commands/find_or_increment_error.rb

@@ -230,6 +230,12 @@ module RailsErrorDashboard
         return {} unless incoming.include?("\n") || incoming.length > stored.length
 
         upgrade = { backtrace: @attributes[:backtrace] }
+        # The source goes with the backtrace it describes: a client's backtrace
+        # replacing a server one must make the row client, and the reverse. A
+        # caller that names none is RED's own server-side code.
+        if ErrorLog.column_names.include?("backtrace_source")
+          upgrade[:backtrace_source] = @attributes[:backtrace_source].presence || "server"
+        end
         # The row is no longer a reconstructed exemplar: it now carries a real
         # stack from a real capture, so it must stop describing itself as
         # "minimal".

data/lib/rails_error_dashboard/commands/flush_missing_translations.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Command: upsert a snapshot of buffered missing-translation counts.
+    #
+    # Receives { "locale\x1Fkey" => [count, source] } from
+    # MissingTranslationTracker and adds each count to its (locale, key,
+    # application) row, creating the row on first sight. find_or_initialize_by
+    # + save! rather than a raw upsert, for cross-database compatibility; a
+    # concurrent first insert of the same key is retried once as a read.
+    #
+    # Runs off the request path (executor to_complete, at_exit). Never raises:
+    # a failed row is logged at debug and the rest of the snapshot still lands.
+    class FlushMissingTranslations
+      def self.call(counts:)
+        new(counts: counts).call
+      end
+
+      def initialize(counts:)
+        @counts = counts || {}
+      end
+
+      def call
+        return if @counts.empty?
+        return unless MissingTranslation.table_exists?
+
+        now = Time.current
+        app_id = current_application_id
+
+        @counts.each do |buffer_key, (count, source)|
+          # A key can be built from user input, so invalid bytes are possible.
+          locale, translation_key = Services::MissingTranslationTracker.parse_key(
+            Services::EncodingSanitizer.scrub(buffer_key.to_s)
+          )
+          next if locale.blank? || translation_key.blank? || count.to_i <= 0
+
+          upsert(locale: locale, translation_key: translation_key,
+                 source: source, count: count.to_i, app_id: app_id, now: now)
+        end
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] FlushMissingTranslations failed: #{e.class} - #{e.message}"
+        )
+      end
+
+      private
+
+      # Insert on first sight; otherwise an atomic SQL increment. A
+      # read-modify-write (load miss_count, add, save) would lose increments
+      # when two threads flush the same hot key at once, and with per-thread
+      # buffers flushing every few seconds that is the common case, not a race
+      # worth ignoring.
+      def upsert(locale:, translation_key:, source:, count:, app_id:, now:)
+        identity = { locale: locale, translation_key: translation_key, application_id: app_id }
+        clean_source = Services::EncodingSanitizer.scrub(source.to_s).presence
+
+        record = MissingTranslation.find_by(identity)
+        if record
+          increment(record, count: count, source: clean_source, now: now)
+        else
+          begin
+            MissingTranslation.create!(identity.merge(
+              miss_count: count, source: clean_source, first_seen_at: now, last_seen_at: now
+            ))
+          rescue ActiveRecord::RecordNotUnique
+            # Another thread inserted the row between our read and our insert:
+            # it exists now, so add to it. A NULL application_id lets both
+            # inserts through on every database; the query merges those rows.
+            record = MissingTranslation.find_by(identity)
+            raise unless record
+
+            increment(record, count: count, source: clean_source, now: now)
+          end
+        end
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] FlushMissingTranslations.upsert failed for #{locale}.#{translation_key}: #{e.class} - #{e.message}"
+        )
+      end
+
+      def increment(record, count:, source:, now:)
+        updates = [ "miss_count = miss_count + ?, last_seen_at = ?", count, now ]
+        # First-write-wins: the first call site seen is the one worth showing,
+        # and overwriting it on every flush would make the column flicker
+        # between callers of the same key. Filled in only while still blank.
+        if record.source.blank? && source
+          updates = [ "miss_count = miss_count + ?, last_seen_at = ?, source = ?", count, now, source ]
+        end
+        MissingTranslation.where(id: record.id).update_all(updates)
+      end
+
+      def current_application_id
+        # The name capture files errors under, so these rows join that app
+        Application.find_by(name: RailsErrorDashboard.resolved_application_name)&.id
+      rescue => e
+        nil
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/flush_rack_attack_events.rb

@@ -83,10 +83,8 @@ module RailsErrorDashboard
       end
 
       def current_application_id
-        app_name = RailsErrorDashboard.configuration.application_name
-        return nil unless app_name.present?
-
-        Application.find_by(name: app_name)&.id
+        # The name capture files errors under, so these rows join that app
+        Application.find_by(name: RailsErrorDashboard.resolved_application_name)&.id
       rescue => e
         nil
       end

data/lib/rails_error_dashboard/commands/flush_storm_counts.rb

@@ -391,6 +391,12 @@ module RailsErrorDashboard
         if ErrorLog.column_names.include?("context_captured_at")
           create_attrs[:context_captured_at] = create_attrs[:occurred_at]
         end
+        # The backtrace above is the exemplar's first frame, so it is a
+        # client's when the counted event was a client report. An entry from
+        # a release that did not record the source reads as server.
+        if ErrorLog.column_names.include?("backtrace_source")
+          create_attrs[:backtrace_source] = entry["capture_source"] == "client" ? "client" : "server"
+        end
         begin
           # requires_new opens a SAVEPOINT: on PostgreSQL a failed INSERT aborts
           # its transaction, and every later statement -- including the recovery
@@ -498,12 +504,7 @@ module RailsErrorDashboard
       end
 
       def resolve_application
-        # Same chain LogError uses — app name is process-global
-        app_name = RailsErrorDashboard.configuration.application_name ||
-                   ENV["APPLICATION_NAME"] ||
-                   (defined?(Rails) && Rails.application.class.module_parent_name) ||
-                   "Rails Application"
-        Application.find_or_create_by_name(app_name)
+        Application.find_or_create_by_name(RailsErrorDashboard.resolved_application_name)
       end
 
       # Record the interval whose per-event timing was lost.

data/lib/rails_error_dashboard/commands/flush_swallowed_exceptions.rb

@@ -90,10 +90,8 @@ module RailsErrorDashboard
       end
 
       def current_application_id
-        app_name = RailsErrorDashboard.configuration.application_name
-        return nil unless app_name.present?
-
-        Application.find_by(name: app_name)&.id
+        # The name capture files errors under, so these rows join that app
+        Application.find_by(name: RailsErrorDashboard.resolved_application_name)&.id
       rescue => e
         nil
       end

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -433,7 +433,7 @@ module RailsErrorDashboard
           error_type: reported_error_type || @exception.class.name,
           message: @exception.message,
           backtrace: truncated_backtrace,
-          user_id: error_context.user_id,
+          user_id: ErrorLog.storable_user_id(error_context.user_id),
           request_url: error_context.request_url,
           request_params: error_context.request_params,
           user_agent: error_context.user_agent,
@@ -513,6 +513,13 @@ module RailsErrorDashboard
           attributes[:environment] = resolve_environment
         end
 
+        # Where the backtrace this row is created with came from. Not part of
+        # the fingerprint: a client report and a server capture of one error
+        # stay one group.
+        if ErrorLog.column_names.include?("backtrace_source")
+          attributes[:backtrace_source] = capture_source
+        end
+
         # Neutralise invalid bytes BEFORE filtering: the filter runs regexes,
         # which raise on an invalid string, and PostgreSQL rejects the INSERT.
         attributes = Services::EncodingSanitizer.scrub_deep(attributes)
@@ -654,8 +661,12 @@ module RailsErrorDashboard
             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")
+            occurrence_attrs[:capture_source] = capture_source if occurrence_columns.include?("capture_source")
             occurrence_attrs = Services::EncodingSanitizer.scrub_deep(occurrence_attrs)
-            ErrorOccurrence.create(ErrorOccurrence.clamp_string_attributes(occurrence_attrs))
+            occurrence = ErrorOccurrence.create(ErrorOccurrence.clamp_string_attributes(occurrence_attrs))
+            # This occurrence's own copy of the context the row just got. Never
+            # raises, so a failure here is never logged as the occurrence's.
+            RecordOccurrenceContext.call(occurrence, attributes) if occurrence.persisted?
           rescue => e
             RailsErrorDashboard::Logger.error("Failed to create error occurrence: #{e.message}")
           end
@@ -799,12 +810,7 @@ module RailsErrorDashboard
       end
 
       def find_or_create_application
-        app_name = RailsErrorDashboard.configuration.application_name ||
-                   ENV["APPLICATION_NAME"] ||
-                   (defined?(Rails) && Rails.application.class.module_parent_name) ||
-                   "Rails Application"
-
-        Application.find_or_create_by_name(app_name)
+        Application.find_or_create_by_name(RailsErrorDashboard.resolved_application_name)
       rescue => e
         RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Failed to find/create application: #{e.message}")
         # Fallback: try to find any application or create default
@@ -1006,6 +1012,12 @@ module RailsErrorDashboard
 
       # Symbol or string key: the async job round-trips the context through the
       # queue serializer, which turns symbol keys into strings.
+      # "client" for a ManualErrorReporter report, "server" for every other
+      # capture. Only the exact marker ManualErrorReporter sets counts.
+      def capture_source
+        context_value(:_capture_source) == "client" ? "client" : "server"
+      end
+
       def context_value(key)
         return nil unless @context.is_a?(Hash)
 

data/lib/rails_error_dashboard/commands/record_occurrence_context.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Keeps one occurrence's moment-of-failure context, then trims the error's
+    # stored contexts to the newest config.occurrence_context_limit.
+    #
+    # The values are the JSON strings LogError has just written to the error
+    # row (breadcrumbs, system health, local and instance variables), so an
+    # occurrence holds exactly what the row would, filtered the same way. A
+    # capture with none of them (a storm-protection :lite capture, or every
+    # feature off) stores nothing.
+    #
+    # Runs inside the capture: it never raises.
+    class RecordOccurrenceContext
+      PIECES = %i[breadcrumbs system_health local_variables instance_variables].freeze
+
+      # @param occurrence [ErrorOccurrence] the occurrence just created
+      # @param attributes [Hash] the attributes LogError wrote to the error row
+      def self.call(occurrence, attributes)
+        new(occurrence, attributes).call
+      end
+
+      def initialize(occurrence, attributes)
+        @occurrence = occurrence
+        @attributes = attributes
+      end
+
+      def call
+        limit = RailsErrorDashboard.configuration.occurrence_context_limit.to_i
+        return if limit <= 0
+
+        values = PIECES.index_with { |piece| @attributes[piece].presence }.compact
+        return if values.empty?
+
+        # An app that updated the gem but has not migrated yet
+        return unless ErrorOccurrenceContext.table_exists?
+
+        ErrorOccurrenceContext.create!(
+          values.merge(error_occurrence_id: @occurrence.id, error_log_id: @occurrence.error_log_id, created_at: Time.current)
+        )
+        trim(limit)
+      rescue => e
+        RailsErrorDashboard::Logger.error(
+          "[RailsErrorDashboard] Failed to record occurrence context: #{e.class}: #{e.message}"
+        )
+        nil
+      end
+
+      private
+
+      # Everything past the newest `limit`, normally the one the insert pushed out
+      def trim(limit)
+        stale = ErrorOccurrenceContext.where(error_log_id: @occurrence.error_log_id)
+          .order(id: :desc).offset(limit).pluck(:id)
+        ErrorOccurrenceContext.where(id: stale).delete_all if stale.any?
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/resolve_error.rb

@@ -31,21 +31,8 @@ module RailsErrorDashboard
         # Dispatch plugin event for resolved error
         PluginRegistry.dispatch(:on_error_resolved, error)
 
-        # Trigger notification callbacks
-        RailsErrorDashboard.configuration.notification_callbacks[:error_resolved].each do |callback|
-          callback.call(error)
-        rescue => e
-          RailsErrorDashboard::Logger.error("Error in error_resolved callback: #{e.message}")
-        end
-
-        # Emit ActiveSupport::Notifications instrumentation event
-        ActiveSupport::Notifications.instrument("error_resolved.rails_error_dashboard", {
-          error_log: error,
-          error_id: error.id,
-          error_type: error.error_type,
-          resolved_by: @resolution_data[:resolved_by_name],
-          resolved_at: error.resolved_at
-        })
+        # Host callbacks (issue-tracker close) and the instrumentation event.
+        Services::ResolutionCallbacks.call(error, resolved_by: @resolution_data[:resolved_by_name])
 
         error
       end

data/lib/rails_error_dashboard/commands/update_error_status.rb

@@ -44,6 +44,13 @@ module RailsErrorDashboard
         # The stat cards are cached; a user action must show up at once.
         Services::AnalyticsCacheManager.clear
 
+        # Moving to "resolved" through the dropdown is a resolution like any
+        # other: the linked issue closes and subscribers hear about it.
+        if @status == "resolved"
+          PluginRegistry.dispatch(:on_error_resolved, error)
+          Services::ResolutionCallbacks.call(error, resolved_by: error.assigned_to)
+        end
+
         { success: true, error: error }
       end