rails_error_dashboard 0.15.0 → 0.16.0

data/db/migrate/20261015000002_add_capture_source_to_error_occurrences_and_error_logs.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Where each capture came from: "server" for RED's own captures (middleware,
+# the Rails.error subscriber, jobs, crash import), "client" for errors sent
+# through ManualErrorReporter by a browser, mobile app or other client.
+#
+#   error_occurrences.capture_source  how this occurrence was captured
+#   error_logs.backtrace_source       where the backtrace the error page shows
+#                                     came from (the group's backtrace can be
+#                                     replaced by a later capture's)
+#
+# A client's backtrace describes code that ran on the client, so the features
+# that read this app's source files for a frame (View Source, git blame, the
+# snippets in Copy for LLM and AI help) skip it.
+#
+# Nullable, no default: NULL is a row from before this migration and reads as
+# server, which is how those rows have always been treated. No index: nothing
+# queries by it. Not part of the fingerprint: a client report and a server
+# capture of the same error stay one group.
+#
+# up/down rather than `change`: the column_exists? guards that make `up` safe
+# to re-run would make a reversed `change` skip the removal.
+class AddCaptureSourceToErrorOccurrencesAndErrorLogs < ActiveRecord::Migration[7.0]
+  COLUMNS = {
+    rails_error_dashboard_error_occurrences: :capture_source,
+    rails_error_dashboard_error_logs: :backtrace_source
+  }.freeze
+
+  def up
+    COLUMNS.each do |table, column|
+      next unless table_exists?(table)
+      next if column_exists?(table, column)
+
+      add_column table, column, :string, limit: 10
+    end
+  end
+
+  def down
+    COLUMNS.each do |table, column|
+      next unless table_exists?(table)
+      next unless column_exists?(table, column)
+
+      remove_column table, column
+    end
+  end
+end

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:
@@ -408,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

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,7 +41,10 @@ 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
 
@@ -62,7 +66,8 @@ module RailsErrorDashboard
           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

@@ -91,10 +91,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_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

@@ -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/configuration.rb

@@ -218,6 +218,7 @@ module RailsErrorDashboard
     # Instance variable capture from tp.self (receiver object at raise time)
     attr_accessor :enable_instance_variables           # Master switch (default: false)
     attr_accessor :instance_variable_max_count          # Max ivars to capture (default: 20)
+    attr_accessor :occurrence_context_limit             # Occurrences per error whose context is kept (default: 25; 0 = off)
     attr_accessor :instance_variable_filter_patterns    # Additional sensitive ivar patterns (default: [])
 
     # Swallowed exception detection via TracePoint(:raise) + TracePoint(:rescue) (Ruby 3.3+ only)
@@ -481,6 +482,9 @@ module RailsErrorDashboard
       # Instance variable capture defaults - OFF by default (opt-in)
       @enable_instance_variables = false         # Capture ivars from tp.self at raise time
       @instance_variable_max_count = 20          # Max ivars per exception
+      # Keep the moment-of-failure context of the newest 25 occurrences of each
+      # error, not only the latest. 0 keeps none.
+      @occurrence_context_limit = 25
       @instance_variable_filter_patterns = []    # Additional sensitive ivar name patterns
 
       # Swallowed exception detection defaults - OFF by default (Ruby 3.3+ opt-in)
@@ -674,6 +678,13 @@ module RailsErrorDashboard
         end
       end
 
+      # Any other git_branch_strategy links to main. A warning, not an error:
+      # a link format is not worth stopping a boot.
+      if git_branch_strategy && !%w[commit_sha current_branch main].include?(git_branch_strategy.to_s)
+        warnings << "git_branch_strategy must be one of :commit_sha, :current_branch or :main " \
+                    "(got: #{git_branch_strategy.inspect}). Repository links will point at main."
+      end
+
       # Validate custom_fingerprint (must respond to .call if set)
       if custom_fingerprint && !custom_fingerprint.respond_to?(:call)
         errors << "custom_fingerprint must respond to .call (lambda, proc, or object with .call method)"
@@ -712,6 +723,10 @@ module RailsErrorDashboard
         errors << "instance_variable_max_count must be at least 1 (got: #{instance_variable_max_count})"
       end
 
+      unless occurrence_context_limit.is_a?(Integer) && occurrence_context_limit >= 0
+        errors << "occurrence_context_limit must be a whole number of 0 or more (got: #{occurrence_context_limit.inspect})"
+      end
+
       # Validate swallowed exception detection settings
       # Auto-disable on Ruby < 3.3 (warn, don't crash)
       if detect_swallowed_exceptions && RUBY_VERSION < "3.3"
@@ -1126,9 +1141,10 @@ module RailsErrorDashboard
       return nil if effective_issue_tracker_provider == :linear
       return nil if git_repository_url.blank?
 
-      # Extract owner/repo from URL: https://github.com/owner/repo(.git)
-      match = git_repository_url.match(%r{[:/]([^/]+/[^/]+?)(?:\.git)?$})
-      match&.[](1)
+      # owner/repo from the normalized URL, so ".git", ".git/" and trailing
+      # slashes all name the same repository the View Source links use
+      url = Services::RepositoryUrl.normalize(git_repository_url)
+      url.match(%r{[:/]([^/]+/[^/]+)\z})&.[](1)
     end
 
     # Resolve the issue tracker API token (supports string or lambda)

data/lib/rails_error_dashboard/error_reporter.rb

@@ -46,8 +46,10 @@ module RailsErrorDashboard
         # Skip duplicate reports from our own middleware when the subscriber
         # already captured this error with full request context above.
         # Without this, async logging enqueues two jobs for one exception —
-        # and non-deterministic job ordering can overwrite good data.
-        if source == "rack.middleware" &&
+        # and non-deterministic job ordering can overwrite good data. The
+        # middleware's report also carries context[:middleware], because Rails
+        # 7.0's reporter passes subscribers no source.
+        if (source == "rack.middleware" || context[:middleware]) &&
            Thread.current[:rails_error_dashboard_reported_errors]&.include?(error.object_id)
           return
         end

data/lib/rails_error_dashboard/manual_error_reporter.rb

@@ -49,7 +49,12 @@ module RailsErrorDashboard
     #   believe they had set a value that was never read.
     # @param source [String, nil] Source identifier (e.g., "frontend", "mobile_app")
     #
-    # @return [ErrorLog, nil] The created error log record, or nil if filtered/ignored
+    # @return [ErrorLog, nil] The created or updated error log record. nil when
+    #   no row is written now, or none is returned:
+    #   - the error is ignored or sampled out (ignored_exceptions, sampling_rate)
+    #   - storm protection only counts it (:count_only)
+    #   - async_logging is on: a job writes the row later
+    #   - logging failed internally (RED never raises into your code)
     #
     # @example Basic usage
     #   ManualErrorReporter.report(
@@ -106,6 +111,11 @@ module RailsErrorDashboard
         occurred_at: occurred_at || Time.current
       }.compact # Remove nil values
 
+      # Marks this as a client report, so nothing reads this app's source files
+      # for its backtrace. Set here, after the caller's values, and from no
+      # argument: source: is only a label.
+      context[:_capture_source] = "client"
+
       # severity is deliberately NOT forwarded: nothing downstream reads it,
       # and passing it on would keep the illusion that it does.
       if severity.present?

data/lib/rails_error_dashboard/middleware/error_catcher.rb

@@ -38,15 +38,19 @@ module RailsErrorDashboard
         # Report to Rails.error (will be logged by our ErrorReporter)
         # CRITICAL: Wrap in rescue to ensure gem failures don't break the app
         begin
-          Rails.error.report(exception,
+          options = {
             handled: false,
             severity: :error,
             context: {
               request: ActionDispatch::Request.new(env),
               middleware: true
-            },
-            source: "rack.middleware"
-          )
+            }
+          }
+          # Rails 7.0's ErrorReporter#report takes no source: keyword (7.1
+          # added it). Passing one raised ArgumentError there, which the rescue
+          # below swallowed, so on 7.0 this middleware reported nothing.
+          options[:source] = "rack.middleware" if report_takes_source?
+          Rails.error.report(exception, **options)
         rescue => e
           # If error reporting fails, log it but DON'T break the app
           RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Middleware error reporting failed: #{e.class} - #{e.message}")
@@ -61,6 +65,16 @@ module RailsErrorDashboard
         Thread.current[:rails_error_dashboard_reported_errors] = nil
         RailsErrorDashboard::Services::BreadcrumbCollector.clear_buffer
       end
+
+      private
+
+      # Asked of the reporter's class, not the object: a stubbed or wrapped
+      # report method hides its real keywords.
+      def report_takes_source?
+        Rails.error.class.instance_method(:report).parameters.any? do |type, name|
+          name == :source || type == :keyrest
+        end
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -29,8 +29,6 @@ module RailsErrorDashboard
             errors_by_hour: errors_by_hour,
             top_users: top_affected_users,
             resolution_rate: resolution_rate,
-            mobile_errors: mobile_errors_count,
-            api_errors: api_errors_count,
             pattern_insights: pattern_insights
           }
         end
@@ -270,16 +268,6 @@ module RailsErrorDashboard
         ((resolved_count.to_f / total_groups) * 100).round(1)
       end
 
-      def mobile_errors_count
-        Queries::EventVolume.in_window(base_scope.where(platform: [ "iOS", "Android" ]), @start_date)
-      end
-
-      def api_errors_count
-        Queries::EventVolume.in_window(
-          base_scope.where("platform IS NULL OR platform = ?", "API"), @start_date
-        )
-      end
-
       #  Pattern insights for top error types
       # Analyzes occurrence patterns and bursts for top 5 error types
       def pattern_insights