rails_error_dashboard 0.15.0 → 0.16.1

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"
@@ -720,6 +735,13 @@ module RailsErrorDashboard
                     "Feature has been auto-disabled. Upgrade Ruby to use this feature."
         @detect_swallowed_exceptions = false
       end
+
+      # Rails 7.0.0-7.0.8.7 render request exceptions without reporting them, so
+      # RED never sees them. Rails 7.0.10 backported 7.1's reporting.
+      if defined?(ActionPack) && ActionPack.gem_version < Gem::Version.new("7.0.10")
+        warnings << "Rails #{ActionPack.gem_version} does not report the request exceptions it renders as error pages, " \
+                    "so unhandled request errors are not recorded. Upgrading to Rails 7.0.10 or later fixes this."
+      end
       # Validate sub-settings only if feature is still active after version check
       if detect_swallowed_exceptions
         if swallowed_exception_max_cache_size && swallowed_exception_max_cache_size < 1
@@ -1126,9 +1148,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

data/lib/rails_error_dashboard/queries/co_occurring_errors.rb

@@ -16,6 +16,13 @@ module RailsErrorDashboard
     #     puts "#{result[:error].error_type} occurred #{result[:frequency]} times together"
     #   end
     class CoOccurringErrors
+      # The newest occurrences of the target error that are compared. This
+      # renders on every error page while the feature is on, and it used to run
+      # one window query per lifetime occurrence: 50k occurrences, 50k queries.
+      TARGET_OCCURRENCES = 500
+      # At most this many occurrences of other errors are read for those windows
+      NEARBY_OCCURRENCES = 20_000
+
       # Find co-occurring errors
       #
       # @param error_log_id [Integer] ID of target error
@@ -34,53 +41,72 @@ module RailsErrorDashboard
         @limit = limit.to_i
       end
 
+      # Four queries however many occurrences there are: the target exists, its
+      # newest occurrence times, other errors' occurrences in those windows, and
+      # the co-occurring errors themselves.
       def find_co_occurring
-        target_error = ErrorLog.find_by(id: @error_log_id)
-        return [] unless target_error
-
-        # Get all occurrences of the target error
-        target_occurrences = ErrorOccurrence.where(error_log_id: @error_log_id)
-        return [] if target_occurrences.empty?
-
-        # For each occurrence, find other errors in the time window
-        co_occurrence_data = Hash.new { |h, k| h[k] = { count: 0, delays: [] } }
+        return [] unless ErrorLog.exists?(id: @error_log_id)
 
-        target_occurrences.find_each do |occurrence|
-          window = @window_minutes.minutes
-          start_time = occurrence.occurred_at - window
-          end_time = occurrence.occurred_at + window
+        targets = ErrorOccurrence.where(error_log_id: @error_log_id)
+          .order(occurred_at: :desc).limit(TARGET_OCCURRENCES).pluck(:occurred_at).sort
+        return [] if targets.empty?
 
-          # Find other error occurrences in this time window
-          nearby_occurrences = ErrorOccurrence
-                                .in_time_window(start_time, end_time)
-                                .where.not(error_log_id: @error_log_id)
-                                .includes(:error_log)
+        window = @window_minutes.minutes
+        stats = Hash.new { |h, k| h[k] = { count: 0, delay_sum: 0.0 } }
 
-          nearby_occurrences.each do |nearby|
-            error_log_id = nearby.error_log_id
-            co_occurrence_data[error_log_id][:count] += 1
+        nearby_occurrences(merged_windows(targets, window)).each do |error_log_id, occurred_at|
+          # Each target occurrence within the window of this one is a pair, as
+          # before. Delay is negative when this error came first.
+          index = targets.bsearch_index { |target| target >= occurred_at - window }
+          next unless index
 
-            # Calculate delay (negative = before, positive = after target error)
-            delay = (nearby.occurred_at - occurrence.occurred_at).to_f
-            co_occurrence_data[error_log_id][:delays] << delay
+          while index < targets.size && targets[index] <= occurred_at + window
+            stats[error_log_id][:count] += 1
+            stats[error_log_id][:delay_sum] += (occurred_at - targets[index]).to_f
+            index += 1
           end
         end
 
-        # Filter by minimum frequency and build results
-        results = co_occurrence_data.select { |_id, data| data[:count] >= @min_frequency }.map do |error_log_id, data|
-          error = ErrorLog.find(error_log_id)
-          avg_delay = data[:delays].sum / data[:delays].size
+        frequent = stats.select { |_id, data| data[:count] >= @min_frequency }
+        errors = ErrorLog.where(id: frequent.keys).index_by(&:id)
 
-          {
-            error: error,
-            frequency: data[:count],
-            avg_delay_seconds: avg_delay.round(2)
-          }
+        results = frequent.filter_map do |error_log_id, data|
+          error = errors[error_log_id] or next
+          { error: error, frequency: data[:count], avg_delay_seconds: (data[:delay_sum] / data[:count]).round(2) }
         end
 
         # Sort by frequency (most common first) and limit results
         results.sort_by { |r| -r[:frequency] }.first(@limit)
       end
+
+      private
+
+      # The windows around each target time, overlapping ones merged, so a burst
+      # of target occurrences becomes one range
+      def merged_windows(targets, window)
+        targets.each_with_object([]) do |target, ranges|
+          from = target - window
+          to = target + window
+          if ranges.any? && from <= ranges.last[1]
+            ranges.last[1] = to
+          else
+            ranges << [ from, to ]
+          end
+        end
+      end
+
+      # [error_log_id, occurred_at] for other errors' occurrences in any window
+      def nearby_occurrences(ranges)
+        column = "#{ErrorOccurrence.table_name}.occurred_at"
+        in_a_window = ranges.map { "(#{column} BETWEEN ? AND ?)" }.join(" OR ")
+
+        ErrorOccurrence
+          .where.not(error_log_id: @error_log_id)
+          .where(in_a_window, *ranges.flatten)
+          .order(occurred_at: :desc)
+          .limit(NEARBY_OCCURRENCES)
+          .pluck(:error_log_id, :occurred_at)
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/platform_comparison.rb

@@ -65,6 +65,13 @@ module RailsErrorDashboard
         @volume ||= Queries::EventVolume.new(base_scope, @start_date)
       end
 
+      # Events per platform for the platforms with errors in the window, the
+      # only ones scored or given a health card. Errors with no platform value
+      # belong to none.
+      def active_error_rates
+        @active_error_rates ||= error_rate_by_platform.except(nil)
+      end
+
       # platform => { error_type => events in the window }.
       #
       # Severity, critical counts and cross-platform totals all fold from this
@@ -158,25 +165,50 @@ module RailsErrorDashboard
       # Higher score = more stable (fewer errors, faster resolution)
       # @return [Hash] Platform => stability score
       def platform_stability_scores
-        platforms = base_scope.distinct.pluck(:platform).compact
-        error_rates = error_rate_by_platform
+        # Only platforms with errors in the window are scored. Every platform
+        # ever seen used to be, and one with none in the window scored 100.
+        error_rates = active_error_rates
+        # A score compares platforms. With fewer than two that have errors in
+        # the window there is nothing to compare against, so none is rated (a
+        # lone platform used to come out Critical every time).
+        return {} if error_rates.size < 2
         resolution_times = resolution_time_by_platform
 
-        # Find max values for normalization
-        max_errors = error_rates.values.max || 1
-        max_resolution_time = resolution_times.values.compact.max || 1
+        total_errors = error_rates.values.sum
+        even_share = 1.0 / error_rates.size
+        fastest_resolution = resolution_times.values_at(*error_rates.keys).compact.min
 
-        platforms.each_with_object({}) do |platform, result|
-          error_count = error_rates[platform] || 0
-          avg_resolution = resolution_times[platform] || 0
+        error_rates.each_with_object({}) do |(platform, error_count), result|
+          avg_resolution = resolution_times[platform]
 
-          # Normalize to 0-1 scale (inverted - lower is better)
-          error_score = 1.0 - (error_count.to_f / max_errors)
-          resolution_score = avg_resolution.positive? ? 1.0 - (avg_resolution / max_resolution_time) : 1.0
+          # This platform's share of all errors against an even split: full
+          # credit at or below it, falling linearly to 0 when one platform has
+          # every error. Against the raw share instead, no evenly split app
+          # could be Healthy. The even-split test is done in integers so an
+          # exact split is never lost to rounding.
+          error_score = if error_count * error_rates.size <= total_errors
+            1.0
+          else
+            1.0 - (((error_count.to_f / total_errors) - even_share) / (1.0 - even_share))
+          end
 
-          # Weight: 70% error count, 30% resolution time
-          # Convert to 0-100 scale
-          result[platform] = ((error_score * 0.7 + resolution_score * 0.3) * 100).round(1)
+          # The fastest platform's average resolution time over this one's,
+          # each floored at one hour: the fastest and any as fast get full
+          # credit, one twice as slow gets half. Against the slowest instead,
+          # the slowest always scored 0 here. The floor keeps an average of 0.0
+          # (resolved at once) from leaving every other platform with none.
+          result[platform] = if avg_resolution
+            resolution_score = [ fastest_resolution, 1.0 ].max / [ avg_resolution, 1.0 ].max
+
+            # Weight: 70% error count, 30% resolution time
+            # Convert to 0-100 scale
+            ((error_score * 0.7 + resolution_score * 0.3) * 100).round(1)
+          else
+            # Nothing resolved in the window: no resolution time to compare, so
+            # the score is the volume credit alone, on the same scale. It used
+            # to get the full resolution credit. The cards say which it is.
+            (error_score * 100).round(1)
+          end
         end
       end
 
@@ -220,12 +252,13 @@ module RailsErrorDashboard
       # Get platform health summary
       # @return [Hash] Platform => health metrics
       def platform_health_summary
-        error_rates = error_rate_by_platform
+        error_rates = active_error_rates
         stability_scores = platform_stability_scores
         severities = severity_distribution_by_platform
         midpoint = @start_date + (@days / 2.0).days
 
-        platforms.each_with_object({}) do |platform, result|
+        # A card for each platform with errors in the window, as the scores
+        error_rates.each_key.with_object({}) do |platform, result|
           platform_scope = base_scope.where(platform: platform)
           groups_in_window = platform_scope.where("occurred_at >= ?", @start_date)
 
@@ -252,9 +285,13 @@ module RailsErrorDashboard
             critical_errors: critical_errors,
             unresolved_errors: unresolved_errors,
             resolution_rate: resolution_rate,
-            stability_score: stability_scores[platform] || 0,
+            # false when nothing from the window is resolved, so the stability
+            # score is volume alone
+            resolution_measured: resolved_errors.positive?,
+            # nil and :not_rated when there are fewer than two platforms
+            stability_score: stability_scores[platform],
             error_velocity: velocity, # Positive = increasing, negative = decreasing
-            health_status: determine_health_status(stability_scores[platform] || 0, velocity)
+            health_status: stability_scores.key?(platform) ? determine_health_status(stability_scores[platform], velocity) : :not_rated
           }
         end
       end

data/lib/rails_error_dashboard/services/backtrace_processor.rb

@@ -99,13 +99,7 @@ module RailsErrorDashboard
         return nil if backtrace.blank?
 
         lines = backtrace.is_a?(String) ? backtrace.split("\n") : backtrace
-        frames = lines.first(20).map do |line|
-          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
+        frames = lines.first(20).map { |line| frame_key(line) }.compact.uniq
 
         return nil if frames.empty?
 
@@ -113,6 +107,21 @@ module RailsErrorDashboard
         Digest::SHA256.hexdigest(file_paths.join("|"))[0..15]
       end
 
+      # "file.rb:method" for one backtrace line, the unit similar-error matching
+      # compares. It accepts Ruby 3.3's in `save' and Ruby 3.4's in 'User#save',
+      # and drops 3.4's class qualifier ("block in User#save" -> "block in
+      # save"), so a frame matches whichever Ruby recorded it.
+      #
+      # @param line [String]
+      # @return [String, nil]
+      def self.frame_key(line)
+        if line =~ %r{([^/]+\.rb):.*?in [`'](.+)'$}
+          "#{Regexp.last_match(1)}:#{Regexp.last_match(2).gsub(/\b[A-Z][\w:]*[#.]/, "")}"
+        elsif line =~ %r{([^/]+\.rb)}
+          Regexp.last_match(1)
+        end
+      end
+
       # Calculate signature directly from Location objects
       # @param locations [Array<Thread::Backtrace::Location>] Backtrace locations
       # @return [String, nil] 16-character hex signature

data/lib/rails_error_dashboard/services/crash_capture.rb

@@ -267,6 +267,11 @@ module RailsErrorDashboard
             attributes[:exception_cause] = cause_json
           end
 
+          # The at_exit hook wrote this backtrace from the crashed process
+          if ErrorLog.column_names.include?("backtrace_source")
+            attributes[:backtrace_source] = "server"
+          end
+
           if ErrorLog.column_names.include?("error_hash")
             attributes[:error_hash] = Services::ErrorHashGenerator.from_attributes(
               error_type: attributes[:error_type],

data/lib/rails_error_dashboard/services/github_link_generator.rb

@@ -77,14 +77,9 @@ module RailsErrorDashboard
 
       private
 
-      # Normalize repository URL (remove .git suffix, trailing slashes, etc.)
-      #
       # @return [String]
       def normalize_repository_url
-        url = repository_url.strip
-        url = url.chomp(".git")
-        url = url.chomp("/")
-        url
+        RepositoryUrl.normalize(repository_url)
       end
 
       # Host of the repository URL, downcased, or nil when the value is not an

data/lib/rails_error_dashboard/services/markdown_error_formatter.rb

@@ -64,33 +64,32 @@ module RailsErrorDashboard
         raw = @error.backtrace
         return nil if raw.blank?
 
-        lines = raw.split("\n")
-        app_lines = lines.reject { |l| l.include?("/gems/") || l.include?("/ruby/") || l.include?("/vendor/") }
-        app_lines = lines.first(MAX_BACKTRACE_LINES) if app_lines.empty?
+        app_lines = app_frames.map { |frame| frame[:full_line] }
+        app_lines = raw.split("\n") if app_lines.empty?
         app_lines = app_lines.first(MAX_BACKTRACE_LINES)
 
         "## Backtrace\n\n```\n#{app_lines.join("\n")}\n```"
       end
 
+      # The application's frames, as the error page classifies them. RED stores
+      # frames shortened ("gems/…", "ruby/…"), so a "/gems/" substring test
+      # kept every gem frame.
+      def app_frames
+        @app_frames ||= Services::BacktraceParser.parse(@error.backtrace.to_s).select { |frame| frame[:category] == :app }
+      end
+
       def source_code_section
         return nil unless defined?(RailsErrorDashboard) &&
           RailsErrorDashboard.configuration.enable_source_code_integration
 
-        raw = @error.backtrace
-        return nil if raw.blank?
-
-        lines = raw.split("\n")
-        app_lines = lines.reject { |l| l.include?("/gems/") || l.include?("/ruby/") || l.include?("/vendor/") }
-        return nil if app_lines.empty?
+        return nil if @error.backtrace.blank? || app_frames.empty?
+        # A client's frames describe code that ran on the client
+        return nil if @error.client_backtrace?
 
         snippets = []
-        app_lines.first(3).each do |frame|
-          # Parse "file:line:in 'method'" format
-          match = frame.match(/^(.+?):(\d+)/)
-          next unless match
-
-          file_path = match[1]
-          line_number = match[2].to_i
+        app_frames.first(3).each do |frame|
+          file_path = frame[:file_path]
+          line_number = frame[:line_number]
 
           reader = Services::SourceCodeReader.new(file_path, line_number)
           source_lines = reader.read_lines(context: 3)

data/lib/rails_error_dashboard/services/repository_url.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # The one normal form of a configured repository URL, shared by the View
+    # Source links and the issue tracker: no surrounding whitespace, no trailing
+    # slashes, no ".git". The slashes go first, or ".git/" keeps its ".git".
+    module RepositoryUrl
+      # @param url [String, nil]
+      # @return [String, nil]
+      def self.normalize(url)
+        return nil if url.nil?
+
+        url.to_s.strip.sub(%r{/+\z}, "").delete_suffix(".git").sub(%r{/+\z}, "")
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/similarity_calculator.rb

@@ -80,19 +80,13 @@ module RailsErrorDashboard
       end
 
       # Extract meaningful frames from backtrace
-      # Format: "file.rb:123:in `method_name`" => "file.rb:method_name"
+      # "file.rb:123:in `name'" (Ruby 3.3) or "file.rb:123:in 'Class#name'"
+      # (Ruby 3.4) => "file.rb:name", via BacktraceProcessor.frame_key
       def extract_frames(backtrace)
         return [] if backtrace.blank?
 
         lines = backtrace.is_a?(String) ? backtrace.split("\n") : backtrace
-        lines.first(20).map do |line|  # Only consider first 20 frames
-          # 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| BacktraceProcessor.frame_key(line) }.compact.uniq  # Only consider first 20 frames
       end
 
       # Normalize message for comparison

data/lib/rails_error_dashboard/services/storm_protection/count_buffer.rb

@@ -38,7 +38,8 @@ module RailsErrorDashboard
         Entry = Struct.new(
           :error_class, :message, :first_app_frame,
           :controller_name, :action_name, :custom_hash, :environment,
-          :opaque_identity, :count, :first_seen_at, :last_seen_at, :buckets
+          :opaque_identity, :count, :first_seen_at, :last_seen_at, :buckets,
+          :capture_source
         )
 
         # The bucket an instant belongs to, as an epoch second.
@@ -120,6 +121,7 @@ module RailsErrorDashboard
               # job CANNOT recompute this -- it has to travel, or a storm count
               # lands on a different row than the full capture path would.
               "opaque_identity" => entry.opaque_identity,
+              "capture_source" => entry.capture_source,
               "count" => entry.count.value,
               "first_seen_at" => entry.first_seen_at.iso8601,
               "last_seen_at" => entry.last_seen_at.iso8601,
@@ -167,7 +169,7 @@ module RailsErrorDashboard
                 parts[:controller_name], parts[:action_name], parts[:custom_hash], parts[:environment],
                 parts[:opaque_identity],
                 Concurrent::AtomicFixnum.new(0), first_seen_at || Time.current, last_seen_at || Time.current,
-                Concurrent::Map.new
+                Concurrent::Map.new, parts[:capture_source]
               )
             end
           end
@@ -216,7 +218,8 @@ module RailsErrorDashboard
             error_class: entry["error_class"], message: entry["message"],
             first_app_frame: entry["first_app_frame"], controller_name: entry["controller_name"],
             action_name: entry["action_name"], custom_hash: entry["custom_hash"],
-            environment: entry["environment"], opaque_identity: entry["opaque_identity"]
+            environment: entry["environment"], opaque_identity: entry["opaque_identity"],
+            capture_source: entry["capture_source"]
           }
         end
 

data/lib/rails_error_dashboard/services/storm_protection/gate.rb

@@ -279,7 +279,12 @@ module RailsErrorDashboard
               # Only an EXPLICIT environment from the caller. nil means "the
               # worker's own environment", resolved at flush time exactly as
               # LogError resolves it for a full capture.
-              environment: context[:environment].to_s.strip.presence&.[](0, 64)
+              environment: context[:environment].to_s.strip.presence&.[](0, 64),
+              # Whose backtrace first_app_frame came from, for the row the flush
+              # may build from it. Not part of the identity or the gate key: a
+              # client report and a server capture of one error share an entry,
+              # which keeps the first event's frame, and so its source.
+              capture_source: context[:_capture_source] == "client" ? "client" : "server"
             )
           end
 

data/lib/rails_error_dashboard/value_objects/occurrence_snapshot.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module ValueObjects
+    # The error as it looked at one occurrence: a read-only copy of the error
+    # row whose breadcrumbs, system health and variables are that occurrence's
+    # stored context. Every other field keeps the row's latest value.
+    #
+    # A real ErrorLog rather than a delegator, so every way a card reads a
+    # piece sees the occurrence's value: the instance-variables card goes
+    # through read_attribute and error.class.column_names, because
+    # Object#instance_variables shadows the attribute reader.
+    module OccurrenceSnapshot
+      # @param error [ErrorLog] the error the context belongs to
+      # @param context [ErrorOccurrenceContext] one of its occurrences' contexts
+      # @return [ErrorLog] read-only; a piece the occurrence did not capture is nil
+      def self.build(error, context)
+        pieces = Commands::RecordOccurrenceContext::PIECES.to_h { |piece| [ piece.to_s, context.read_attribute(piece) ] }
+        error.class.instantiate(error.attributes_before_type_cast.merge(pieces)).tap(&:readonly!)
+      end
+    end
+  end
+end