rails_error_dashboard 0.15.0 → 0.16.0

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

@@ -160,18 +160,25 @@ module RailsErrorDashboard
       def platform_stability_scores
         platforms = base_scope.distinct.pluck(:platform).compact
         error_rates = error_rate_by_platform
+        # 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). The count is of
+        # platforms with errors in the window: the list above is every
+        # platform ever seen.
+        return {} if error_rates.size < 2
         resolution_times = resolution_time_by_platform
 
-        # Find max values for normalization
-        max_errors = error_rates.values.max || 1
+        total_errors = error_rates.values.sum
         max_resolution_time = resolution_times.values.compact.max || 1
 
         platforms.each_with_object({}) do |platform, result|
           error_count = error_rates[platform] || 0
           avg_resolution = resolution_times[platform] || 0
 
-          # Normalize to 0-1 scale (inverted - lower is better)
-          error_score = 1.0 - (error_count.to_f / max_errors)
+          # This platform's share of all errors, inverted. Against the busiest
+          # platform instead, the busiest always scored 0 here and so was always
+          # Critical.
+          error_score = total_errors.positive? ? 1.0 - (error_count.to_f / total_errors) : 1.0
           resolution_score = avg_resolution.positive? ? 1.0 - (avg_resolution / max_resolution_time) : 1.0
 
           # Weight: 70% error count, 30% resolution time
@@ -252,9 +259,10 @@ module RailsErrorDashboard
             critical_errors: critical_errors,
             unresolved_errors: unresolved_errors,
             resolution_rate: resolution_rate,
-            stability_score: stability_scores[platform] || 0,
+            # 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

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.15.0"
+  VERSION = "0.16.0"
 end

data/lib/rails_error_dashboard.rb

@@ -23,6 +23,7 @@ begin; require "turbo-rails"; rescue LoadError; end
 # Core library files
 require "rails_error_dashboard/value_objects/error_context"
 require "rails_error_dashboard/value_objects/llm_call_event"
+require "rails_error_dashboard/value_objects/occurrence_snapshot"
 require "rails_error_dashboard/integrations/o_tel"
 require "rails_error_dashboard/integrations/tracer"
 require "rails_error_dashboard/integrations/llm_span_processor"
@@ -59,6 +60,7 @@ require "rails_error_dashboard/services/source_code_reader"
 require "rails_error_dashboard/services/git_blame_reader"
 require "rails_error_dashboard/services/git_head_reader"
 require "rails_error_dashboard/services/solid_queue_config_check"
+require "rails_error_dashboard/services/repository_url"
 require "rails_error_dashboard/services/github_link_generator"
 require "rails_error_dashboard/services/cause_chain_extractor"
 require "rails_error_dashboard/services/environment_snapshot"
@@ -116,6 +118,7 @@ require "rails_error_dashboard/queries/error_cascades"
 require "rails_error_dashboard/queries/baseline_stats"
 require "rails_error_dashboard/queries/platform_comparison"
 require "rails_error_dashboard/queries/error_correlation"
+require "rails_error_dashboard/commands/record_occurrence_context"
 require "rails_error_dashboard/commands/log_error"
 require "rails_error_dashboard/commands/resolve_error"
 require "rails_error_dashboard/commands/create_issue"
@@ -226,6 +229,19 @@ module RailsErrorDashboard
     remove_instance_variable(:@detected_git_sha) if defined?(@detected_git_sha)
   end
 
+  # The name errors are filed under: config.application_name, then the
+  # APPLICATION_NAME variable, then the Rails app's module name. Capture, the
+  # storm and event flushers, and the backfill all use this one chain, or the
+  # same app's rows end up under two Applications, or under none.
+  #
+  # @return [String]
+  def self.resolved_application_name
+    configuration.application_name.presence ||
+      ENV["APPLICATION_NAME"].presence ||
+      (defined?(Rails) && Rails.application&.class&.module_parent_name) ||
+      "Rails Application"
+  end
+
   # Register a plugin
   # @param plugin [Plugin] The plugin instance to register
   # @return [Boolean] True if registered successfully, false otherwise

data/lib/tasks/error_dashboard.rake

@@ -335,9 +335,8 @@ namespace :error_dashboard do
 
   desc "Backfill application_id for existing errors"
   task backfill_application: :environment do
-    app_name = ENV["APP_NAME"] || ENV["APPLICATION_NAME"] ||
-               (defined?(Rails) && Rails.application.class.module_parent_name) ||
-               "Legacy Application"
+    # APP_NAME overrides; otherwise the name capture files new errors under
+    app_name = ENV["APP_NAME"].presence || RailsErrorDashboard.resolved_application_name
 
     puts "\n" + "=" * 80
     puts "RAILS ERROR DASHBOARD - BACKFILL APPLICATION"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -312,6 +312,7 @@ files:
 - app/models/rails_error_dashboard/error_log.rb
 - app/models/rails_error_dashboard/error_logs_record.rb
 - app/models/rails_error_dashboard/error_occurrence.rb
+- app/models/rails_error_dashboard/error_occurrence_context.rb
 - app/models/rails_error_dashboard/event_count.rb
 - app/models/rails_error_dashboard/event_timing_gap.rb
 - app/models/rails_error_dashboard/missing_translation.rb
@@ -326,6 +327,7 @@ files:
 - app/views/rails_error_dashboard/error_notification_mailer/error_alert.text.erb
 - app/views/rails_error_dashboard/errors/_ai_help_panel.html.erb
 - app/views/rails_error_dashboard/errors/_breadcrumbs_group.html.erb
+- app/views/rails_error_dashboard/errors/_captured_occurrences.html.erb
 - app/views/rails_error_dashboard/errors/_co_occurring_errors.html.erb
 - app/views/rails_error_dashboard/errors/_discussion.html.erb
 - app/views/rails_error_dashboard/errors/_error_cascades.html.erb
@@ -336,6 +338,7 @@ files:
 - app/views/rails_error_dashboard/errors/_llm_summary.html.erb
 - app/views/rails_error_dashboard/errors/_local_variables.html.erb
 - app/views/rails_error_dashboard/errors/_modals.html.erb
+- app/views/rails_error_dashboard/errors/_occurrence_banner.html.erb
 - app/views/rails_error_dashboard/errors/_pattern_insights.html.erb
 - app/views/rails_error_dashboard/errors/_request_context.html.erb
 - app/views/rails_error_dashboard/errors/_show_scripts.html.erb
@@ -432,6 +435,8 @@ files:
 - db/migrate/20260920000001_add_buckets_incomplete_to_storm_events.rb
 - db/migrate/20260920000002_create_event_timing_gaps.rb
 - db/migrate/20261010000001_create_missing_translations.rb
+- db/migrate/20261015000001_create_rails_error_dashboard_error_occurrence_contexts.rb
+- db/migrate/20261015000002_add_capture_source_to_error_occurrences_and_error_logs.rb
 - lib/generators/rails_error_dashboard/install/install_generator.rb
 - lib/generators/rails_error_dashboard/install/templates/README
 - lib/generators/rails_error_dashboard/install/templates/initializer.rb
@@ -459,6 +464,7 @@ files:
 - lib/rails_error_dashboard/commands/link_existing_issue.rb
 - lib/rails_error_dashboard/commands/log_error.rb
 - lib/rails_error_dashboard/commands/mute_error.rb
+- lib/rails_error_dashboard/commands/record_occurrence_context.rb
 - lib/rails_error_dashboard/commands/resolve_error.rb
 - lib/rails_error_dashboard/commands/scrub_invalid_encoding.rb
 - lib/rails_error_dashboard/commands/snooze_error.rb
@@ -573,6 +579,7 @@ files:
 - lib/rails_error_dashboard/services/platform_detector.rb
 - lib/rails_error_dashboard/services/priority_score_calculator.rb
 - lib/rails_error_dashboard/services/rack_attack_tracker.rb
+- lib/rails_error_dashboard/services/repository_url.rb
 - lib/rails_error_dashboard/services/resolution_callbacks.rb
 - lib/rails_error_dashboard/services/rspec_generator.rb
 - lib/rails_error_dashboard/services/sensitive_data_filter.rb
@@ -605,6 +612,7 @@ files:
 - lib/rails_error_dashboard/translation.rb
 - lib/rails_error_dashboard/value_objects/error_context.rb
 - lib/rails_error_dashboard/value_objects/llm_call_event.rb
+- lib/rails_error_dashboard/value_objects/occurrence_snapshot.rb
 - lib/rails_error_dashboard/version.rb
 - lib/tasks/error_dashboard.rake
 - lib/tasks/rails_error_dashboard_tasks.rake
@@ -620,7 +628,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.15.0
+    RED (Rails Error Dashboard) v0.16.0
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install: