rails_error_dashboard 0.11.9 → 0.12.0

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -19,9 +19,14 @@ module RailsErrorDashboard
         begin
           Rails.cache.fetch(cache_key, expires_in: 1.minute) do
             {
-              total_today: base_scope.where("occurred_at >= ?", Time.current.beginning_of_day).count,
-              total_week: base_scope.where("occurred_at >= ?", 7.days.ago).count,
-              total_month: base_scope.where("occurred_at >= ?", 30.days.ago).count,
+              # EVENTS, not groups. An ErrorLog row is a group whose
+              # occurrence_count says how many times it happened, so counting
+              # rows reported five users hitting one error as "1 error today".
+              # Summing is also exact during a storm: counted-only events never
+              # create occurrence rows, but they DO raise occurrence_count.
+              total_today: event_count_since(Time.current.beginning_of_day),
+              total_week: event_count_since(7.days.ago),
+              total_month: event_count_since(30.days.ago),
               unresolved: base_scope.unresolved.count,
               resolved: base_scope.resolved.count,
               reopened: reopened_count,
@@ -40,7 +45,13 @@ module RailsErrorDashboard
               trend_percentage: trend_percentage,
               trend_direction: trend_direction,
               top_errors_by_impact: top_errors_by_impact,
-              average_resolution_time: average_resolution_time
+              average_resolution_time: average_resolution_time,
+              # Affected-user figures come from occurrence rows, which storm
+              # count-only events never create. When that happened in the
+              # window, the dimension is incomplete and the page says so
+              # rather than presenting an undercount as fact.
+              affected_users_incomplete: affected_users_incomplete?,
+              data_unavailable: false
             }
           end
         rescue => e
@@ -50,7 +61,13 @@ module RailsErrorDashboard
           RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Backtrace: #{e.backtrace&.first(3)&.join("\n")}")
 
           # Return minimal stats hash to prevent nil errors in views
+          # Zero errors and "we could not read the data" are different states.
+          # Reporting healthy-looking zeros made a failed dashboard query
+          # indistinguishable from a quiet day; data_unavailable lets the page
+          # say which it is.
           {
+            data_unavailable: true,
+            affected_users_incomplete: false,
             total_today: 0,
             total_week: 0,
             total_month: 0,
@@ -95,6 +112,46 @@ module RailsErrorDashboard
         scope
       end
 
+      # Total EVENTS in a window: the sum of every matching group's
+      # occurrence_count. platform_comparison.rb counts the same way.
+      def event_count_since(since)
+        base_scope.where("occurred_at >= ?", since).sum(:occurrence_count)
+      end
+
+      def event_count_between(from, to)
+        base_scope.where("occurred_at >= ? AND occurred_at < ?", from, to).sum(:occurrence_count)
+      end
+
+      # Occurrence rows carry the user of EACH event. The group's user_id is
+      # mutable -- refreshed by the latest occurrence -- so counting it
+      # distinct over groups can only ever yield zero or one per group.
+      def occurrence_scope
+        occurrences = ErrorOccurrence.table_name
+        scope = ErrorOccurrence.joins(:error_log)
+        scope = scope.where(ErrorLog.table_name => { application_id: @application_id }) if @application_id.present?
+        scope
+      end
+
+      def occurrences_available?
+        defined?(ErrorOccurrence) && ErrorOccurrence.table_exists?
+      rescue StandardError
+        false
+      end
+
+      # True when the window contains more events than recorded occurrences --
+      # i.e. storm shedding dropped per-event rows, so any occurrence-derived
+      # dimension (affected users) is a floor, not a total.
+      def affected_users_incomplete?
+        return false unless occurrences_available?
+
+        recorded = occurrence_scope
+                     .where("#{ErrorOccurrence.table_name}.occurred_at >= ?", Time.current.beginning_of_day)
+                     .count
+        recorded < event_count_since(Time.current.beginning_of_day)
+      rescue StandardError
+        false
+      end
+
       def reopened_count
         return 0 unless ErrorLog.column_names.include?("reopened_at")
 
@@ -104,7 +161,7 @@ module RailsErrorDashboard
       def top_errors
         base_scope.where("occurred_at >= ?", 7.days.ago)
                   .group(:error_type)
-                  .count
+                  .sum(:occurrence_count)
                   .sort_by { |_, count| -count }
                   .first(10)
                   .to_h
@@ -114,7 +171,7 @@ module RailsErrorDashboard
       def errors_trend_7d
         base_scope.where("occurred_at >= ?", 7.days.ago)
                   .group_by_day(:occurred_at, range: 7.days.ago.to_date..Date.current, default_value: 0)
-                  .count
+                  .sum(:occurrence_count)
       end
 
       # Get error counts by severity for last 7 days
@@ -123,14 +180,14 @@ module RailsErrorDashboard
         scoped_errors = base_scope.where("occurred_at >= ?", 7.days.ago)
 
         {
-          critical: scoped_errors.where(error_type: Services::SeverityClassifier::CRITICAL_ERROR_TYPES).count,
-          high: scoped_errors.where(error_type: Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES).count,
-          medium: scoped_errors.where(error_type: Services::SeverityClassifier::MEDIUM_SEVERITY_ERROR_TYPES).count,
+          critical: scoped_errors.where(error_type: Services::SeverityClassifier::CRITICAL_ERROR_TYPES).sum(:occurrence_count),
+          high: scoped_errors.where(error_type: Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES).sum(:occurrence_count),
+          medium: scoped_errors.where(error_type: Services::SeverityClassifier::MEDIUM_SEVERITY_ERROR_TYPES).sum(:occurrence_count),
           low: scoped_errors.where.not(
             error_type: Services::SeverityClassifier::CRITICAL_ERROR_TYPES +
                        Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES +
                        Services::SeverityClassifier::MEDIUM_SEVERITY_ERROR_TYPES
-          ).count
+          ).sum(:occurrence_count)
         }
       end
 
@@ -139,7 +196,7 @@ module RailsErrorDashboard
       def spike_detected?
         return false if errors_trend_7d.empty?
 
-        today_count = base_scope.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        today_count = event_count_since(Time.current.beginning_of_day)
 
         # Try baseline-based detection first
         if baseline_anomaly_detected?(today_count)
@@ -158,7 +215,7 @@ module RailsErrorDashboard
       def spike_info
         return nil unless spike_detected?
 
-        today_count = base_scope.where("occurred_at >= ?", Time.current.beginning_of_day).count
+        today_count = event_count_since(Time.current.beginning_of_day)
         avg_count = (errors_trend_7d.values.sum / 7.0).round(1)
 
         info = {
@@ -218,42 +275,50 @@ module RailsErrorDashboard
         }
       end
 
-      # Calculate error rate as a percentage
-      # Since we don't track total requests, we'll use error count as proxy
-      # In the future, this could be: (errors / total_requests) * 100
+      # Errors per hour so far today. NOT a percentage.
+      #
+      # This value was rendered with a "%" sign against a scale that mapped
+      # one error per hour to "1%", and was capped at 100 -- a rate of 4,000
+      # errors/hour displayed as "100%". There is no request denominator to
+      # make a real failure percentage from, so the honest figure is the rate
+      # itself, uncapped, labelled with its unit.
       def error_rate
-        today_errors = base_scope.where("occurred_at >= ?", Time.current.beginning_of_day).count
-        return 0.0 if today_errors.zero?
+        today_events = event_count_since(Time.current.beginning_of_day)
+        return 0.0 if today_events.zero?
 
-        # For now, use a simple heuristic: errors per hour today
-        # Assume we want < 1 error per hour = good (< 1%)
-        # 1-5 errors per hour = warning (1-5%)
-        # > 5 errors per hour = critical (> 5%)
         hours_today = ((Time.current - Time.current.beginning_of_day) / 1.hour).round(1)
-        hours_today = 1.0 if hours_today < 1.0 # Avoid division by zero in early morning
+        hours_today = 1.0 if hours_today < 1.0 # Avoid dividing by ~0 just after midnight
 
-        errors_per_hour = today_errors / hours_today
-        # Convert to percentage scale (0-100)
-        # Scale: 0 errors/hr = 0%, 1 error/hr = 1%, 10 errors/hr = 10%, etc.
-        [ errors_per_hour, 100.0 ].min.round(1)
+        (today_events / hours_today).round(1)
       end
 
-      # Count distinct users affected by errors today
+      # Distinct users affected today, counted from OCCURRENCE rows.
+      #
+      # The group's user_id is overwritten by each new occurrence, so counting
+      # it distinct across groups reported five users hitting one error as one
+      # affected user. Storm count-only events create no occurrence row, so
+      # this is a floor during a storm -- affected_users_incomplete? says when.
       def affected_users_today
-        base_scope.where("occurred_at >= ?", Time.current.beginning_of_day)
-                  .where.not(user_id: nil)
-                  .distinct
-                  .count(:user_id)
+        distinct_affected_users(Time.current.beginning_of_day, nil)
       end
 
-      # Count distinct users affected by errors yesterday
       def affected_users_yesterday
-        base_scope.where("occurred_at >= ? AND occurred_at < ?",
-                        1.day.ago.beginning_of_day,
-                        Time.current.beginning_of_day)
-                  .where.not(user_id: nil)
-                  .distinct
-                  .count(:user_id)
+        distinct_affected_users(1.day.ago.beginning_of_day, Time.current.beginning_of_day)
+      end
+
+      def distinct_affected_users(from, to)
+        unless occurrences_available?
+          scope = base_scope.where("occurred_at >= ?", from)
+          scope = scope.where("occurred_at < ?", to) if to
+          return scope.where.not(user_id: nil).distinct.count(:user_id)
+        end
+
+        occurrences = ErrorOccurrence.table_name
+        scope = occurrence_scope.where("#{occurrences}.occurred_at >= ?", from)
+        scope = scope.where("#{occurrences}.occurred_at < ?", to) if to
+        scope.where.not(occurrences => { user_id: nil }).distinct.count("#{occurrences}.user_id")
+      rescue StandardError
+        0
       end
 
       # Calculate change in affected users (today vs yesterday)
@@ -269,10 +334,8 @@ module RailsErrorDashboard
 
       # Calculate percentage change in errors (today vs yesterday)
       def trend_percentage
-        today = base_scope.where("occurred_at >= ?", Time.current.beginning_of_day).count
-        yesterday = base_scope.where("occurred_at >= ? AND occurred_at < ?",
-                                     1.day.ago.beginning_of_day,
-                                     Time.current.beginning_of_day).count
+        today = event_count_since(Time.current.beginning_of_day)
+        yesterday = event_count_between(1.day.ago.beginning_of_day, Time.current.beginning_of_day)
 
         return 0.0 if today.zero? && yesterday.zero?
         return 100.0 if yesterday.zero? && today.positive?
@@ -295,26 +358,49 @@ module RailsErrorDashboard
 
       # Get top 6 errors ranked by impact score
       # Impact = affected_users_count × occurrence_count
+      # Top errors by impact = distinct affected users x events.
+      #
+      # This grouped by each row's own id and counted DISTINCT user_id within
+      # that single row, which can only be zero or one -- so every error's
+      # "affected users" was 1 and the impact score was just its occurrence
+      # count. The user count comes from occurrence rows, where each event
+      # carries its own user.
       def top_errors_by_impact
-        base_scope.where("occurred_at >= ?", 7.days.ago)
-                .group(:error_type, :id)
-                .select("error_type, id, message, occurred_at, occurrence_count,
-                        COUNT(DISTINCT user_id) as affected_users,
-                        COUNT(DISTINCT user_id) * occurrence_count as impact_score")
-                .order("impact_score DESC")
-                .limit(6)
-                .map do |error|
-                  {
-                    id: error.id,
-                    error_type: error.error_type,
-                    message: error.message&.truncate(80),
-                    severity: Services::SeverityClassifier.classify(error.error_type),
-                    occurrence_count: error.occurrence_count,
-                    affected_users: error.affected_users.to_i,
-                    impact_score: error.impact_score.to_i,
-                    occurred_at: error.occurred_at
-                  }
-                end
+        errors = base_scope.where("occurred_at >= ?", 7.days.ago)
+                           .order(occurrence_count: :desc)
+                           .limit(50)
+                           .to_a
+        return [] if errors.empty?
+
+        users_by_error = distinct_users_by_error_log(errors.map(&:id))
+
+        errors.map { |error|
+          affected = users_by_error.fetch(error.id, error.user_id.present? ? 1 : 0)
+          {
+            id: error.id,
+            error_type: error.error_type,
+            message: error.message&.truncate(80),
+            severity: Services::SeverityClassifier.classify(error.error_type),
+            occurrence_count: error.occurrence_count,
+            affected_users: affected,
+            impact_score: affected * error.occurrence_count.to_i,
+            occurred_at: error.occurred_at
+          }
+        }.sort_by { |entry| -entry[:impact_score] }.first(6)
+      end
+
+      # error_log_id => distinct users with a recorded occurrence.
+      def distinct_users_by_error_log(error_log_ids)
+        return {} unless occurrences_available?
+        return {} if error_log_ids.empty?
+
+        ErrorOccurrence.where(error_log_id: error_log_ids)
+                       .where.not(user_id: nil)
+                       .group(:error_log_id)
+                       .distinct
+                       .count(:user_id)
+      rescue StandardError
+        {}
       end
 
       # Calculate average resolution time (MTTR) in hours for the last 30 days

data/lib/rails_error_dashboard/queries/user_impact_summary.rb

@@ -37,15 +37,16 @@ module RailsErrorDashboard
       end
 
       def build_entries
-        # Group by error_type, count distinct users and total occurrences
-        user_counts = base_scope
-          .group(:error_type)
-          .distinct
-          .count(:user_id)
+        # Distinct users per error type, from OCCURRENCE rows: the group's
+        # user_id is overwritten by each new occurrence, so counting it
+        # distinct across groups reported five users hitting one error as one.
+        user_counts = distinct_users_by_type
 
+        # EVENTS per type, not groups. occurrence_count is exact and includes
+        # storm-shed events, which create no occurrence row.
         occurrence_counts = base_scope
           .group(:error_type)
-          .count
+          .sum(:occurrence_count)
 
         total_users = effective_total_users
 
@@ -73,12 +74,61 @@ module RailsErrorDashboard
       def build_summary(entries)
         {
           total_error_types_with_users: entries.size,
-          total_unique_users_affected: entries.sum { |e| e[:unique_users] },
+          # Summing per-type distinct counts counted one user once per type
+          # they hit. One distinct count across the whole window is the actual
+          # number of people affected.
+          total_unique_users_affected: total_distinct_users(entries),
           most_impactful: entries.first&.dig(:error_type),
           total_users: effective_total_users
         }
       end
 
+      def occurrences_available?
+        defined?(ErrorOccurrence) && ErrorOccurrence.table_exists?
+      rescue StandardError
+        false
+      end
+
+      # error_type => distinct users who actually experienced it.
+      def distinct_users_by_type
+        unless occurrences_available?
+          return base_scope.group(:error_type).distinct.count(:user_id)
+        end
+
+        occurrences = ErrorOccurrence.table_name
+        logs = ErrorLog.table_name
+        scope = ErrorOccurrence.joins(:error_log)
+                               .where("#{occurrences}.occurred_at >= ?", @start_date)
+                               .where.not(occurrences => { user_id: nil })
+        scope = scope.where(logs => { application_id: @application_id }) if @application_id.present?
+
+        counts = scope.group("#{logs}.error_type").distinct.count("#{occurrences}.user_id")
+        # An error whose events predate occurrence tracking still belongs in
+        # the list; fall back to the group's own user for those types.
+        fallback = base_scope.group(:error_type).distinct.count(:user_id)
+        fallback.merge(counts) { |_type, old_count, new_count| [ old_count, new_count ].max }
+      rescue StandardError
+        base_scope.group(:error_type).distinct.count(:user_id)
+      end
+
+      # One distinct count over the whole window, not a sum of per-type counts.
+      def total_distinct_users(entries)
+        unless occurrences_available?
+          return base_scope.distinct.count(:user_id)
+        end
+
+        occurrences = ErrorOccurrence.table_name
+        logs = ErrorLog.table_name
+        scope = ErrorOccurrence.joins(:error_log)
+                               .where("#{occurrences}.occurred_at >= ?", @start_date)
+                               .where.not(occurrences => { user_id: nil })
+        scope = scope.where(logs => { application_id: @application_id }) if @application_id.present?
+
+        [ scope.distinct.count("#{occurrences}.user_id"), entries.map { |e| e[:unique_users] }.max.to_i ].max
+      rescue StandardError
+        entries.sum { |e| e[:unique_users] }
+      end
+
       def effective_total_users
         RailsErrorDashboard.configuration.effective_total_users
       rescue => e

data/lib/rails_error_dashboard/services/error_hash_generator.rb

@@ -27,21 +27,61 @@ module RailsErrorDashboard
         custom = try_custom_fingerprint(exception, context)
         return custom if custom
 
-        normalized_message = normalize_message(exception.message)
-        file_path = extract_app_frame_from_locations(exception) || extract_app_frame(exception.backtrace)
+        complete(
+          opaque_identity(
+            error_class: exception.class.name,
+            normalized_message: normalize_message(exception.message),
+            frames: extract_app_frame_from_locations(exception) || extract_app_frame(exception.backtrace),
+            controller_name: controller_name,
+            action_name: action_name
+          ),
+          application_id
+        )
+      end
 
+      # The half of the fingerprint that needs no database.
+      #
+      # WHY THE HASH IS TWO-STAGE: capture identity has to be computed from the
+      # RAW message (redacting first would re-group every error whose message
+      # contains a filtered key), but the async and storm paths compute it on
+      # the request thread and hand it to a worker over a queue. Shipping the
+      # raw message to do that put secrets in the queue's backing store, its
+      # backups and any job-argument logging -- the error row was redacted, the
+      # payload was not.
+      #
+      # Hashing the identity parts here makes the value that crosses the queue
+      # opaque and irreversible, so no message text needs to travel for
+      # grouping to work. The worker calls .complete with application_id, which
+      # it can resolve because it is allowed to touch the database.
+      #
+      # application_id is NOT part of this digest: resolving it means
+      # Application.find_or_create_by_name, a write, and the capture path
+      # promises no I/O on the request thread.
+      #
+      # @return [String] 16-character hex digest of the non-application parts
+      def self.opaque_identity(error_class:, normalized_message:, frames:, controller_name: nil, action_name: nil)
         digest_input = [
-          exception.class.name,
+          error_class,
           normalized_message,
-          file_path,
+          frames,
           controller_name,
-          action_name,
-          application_id.to_s
+          action_name
         ].compact.join("|")
 
         Digest::SHA256.hexdigest(digest_input)[0..15]
       end
 
+      # Combine an opaque identity with the application to get the canonical
+      # error_hash. Every path -- sync capture, async worker, storm flush --
+      # finishes here, so a fingerprint is the same value however it travelled.
+      #
+      # @param opaque [String] from .opaque_identity (or a custom fingerprint)
+      # @param application_id [Integer, nil]
+      # @return [String] 16-character hex hash
+      def self.complete(opaque, application_id)
+        Digest::SHA256.hexdigest("#{opaque}|#{application_id}")[0..15]
+      end
+
       # Generate hash from error attributes (used by ErrorLog model callback)
       # Uses ErrorNormalizer for smarter normalization and significant frame extraction
       # @param error_type [String] The error class name
@@ -52,19 +92,21 @@ module RailsErrorDashboard
       # @param application_id [Integer, nil] Application for per-app deduplication
       # @return [String] 16-character hex hash
       def self.from_attributes(error_type:, message: nil, backtrace: nil, controller_name: nil, action_name: nil, application_id: nil)
-        normalized_message = ErrorNormalizer.normalize(message)
-        significant_frames = ErrorNormalizer.extract_significant_frames(backtrace, count: 3)
-
-        digest_input = [
-          error_type,
-          normalized_message,
-          significant_frames,
-          controller_name,
-          action_name,
-          application_id.to_s
-        ].compact.join("|")
-
-        Digest::SHA256.hexdigest(digest_input)[0..15]
+        # Deliberately a DIFFERENT recipe from .call: ErrorNormalizer's smarter
+        # normalization and three significant frames, rather than a prefix of
+        # the message and one app frame. The two entry points have always
+        # produced different hashes for the same error; unifying them would
+        # re-group every existing row. They share only the two-stage shape.
+        complete(
+          opaque_identity(
+            error_class: error_type,
+            normalized_message: ErrorNormalizer.normalize(message),
+            frames: ErrorNormalizer.extract_significant_frames(backtrace, count: 3),
+            controller_name: controller_name,
+            action_name: action_name
+          ),
+          application_id
+        )
       end
 
       # Only this many leading characters of the RAW message take part in the

data/lib/rails_error_dashboard/services/issue_tracker_client.rb

@@ -63,6 +63,44 @@ module RailsErrorDashboard
         nil
       end
 
+      # Build a client for the identity an ERROR is actually linked to, rather
+      # than whatever the global configuration currently points at.
+      #
+      # An outbound comment or close must reach the repository the issue was
+      # opened in. With the repo taken from configuration, re-pointing
+      # issue_tracker_repo (or running one database across several apps) sent
+      # those calls to the wrong repository -- against an issue number that
+      # exists in both.
+      #
+      # Falls back to the configured repo when the error predates the recorded
+      # identity, which is the previous behaviour.
+      #
+      # @param error [ErrorLog]
+      # @return [IssueTrackerClient, nil]
+      def self.for_error(error)
+        config = RailsErrorDashboard.configuration
+        return nil unless config.enable_issue_tracking
+
+        provider = error.external_issue_provider.presence || config.effective_issue_tracker_provider
+        return nil unless provider
+
+        repo = nil
+        if error.respond_to?(:external_issue_repo)
+          repo = error.external_issue_repo.presence
+        end
+        repo ||= config.effective_issue_tracker_repo
+
+        token = config.effective_issue_tracker_token
+        return nil unless token && repo
+
+        self.for(provider, token: token, repo: repo, api_url: config.effective_issue_tracker_api_url)
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] IssueTrackerClient.for_error failed: #{e.class} - #{e.message}"
+        )
+        nil
+      end
+
       def initialize(token:, repo:, api_url: nil)
         @token = token
         @repo = repo

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

@@ -29,7 +29,7 @@ module RailsErrorDashboard
         Entry = Struct.new(
           :error_class, :message, :first_app_frame,
           :controller_name, :action_name, :custom_hash, :environment,
-          :count, :first_seen_at, :last_seen_at
+          :opaque_identity, :count, :first_seen_at, :last_seen_at
         )
 
         def initialize
@@ -97,13 +97,31 @@ module RailsErrorDashboard
               "action_name" => entry.action_name,
               "custom_hash" => entry.custom_hash,
               "environment" => entry.environment,
+              # The fingerprint, hashed from the RAW message at the gate.
+              # "message" above is REDACTED before it is buffered, so the flush
+              # 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,
               "count" => entry.count.value,
               "first_seen_at" => entry.first_seen_at.iso8601,
               "last_seen_at" => entry.last_seen_at.iso8601
             }
           end
 
-          { entries: entries, overflow: overflow }
+          # A unique identity for THIS swap of the buffer.
+          #
+          # The batch digest is built from the entries and their counts, which
+          # makes a replay recognisable -- but it also makes two SEPARATE
+          # batches indistinguishable when they happen to carry identical
+          # counts for the same fingerprints (timestamps are second-granular,
+          # so a storm flushing twice inside one second collides). The second
+          # batch would then be dropped as a replay, losing real counts.
+          #
+          # Minted here because this is the moment a batch comes into
+          # existence: every entry in it was removed from the buffer by this
+          # swap and appears in no other batch. A retry of the same batch
+          # carries the same id, which is exactly what the ledger must catch.
+          { entries: entries, overflow: overflow, batch_id: SecureRandom.uuid }
         end
 
         private
@@ -124,6 +142,7 @@ module RailsErrorDashboard
               Entry.new(
                 parts[:error_class], parts[:message], parts[:first_app_frame],
                 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
               )
             end
@@ -139,7 +158,7 @@ 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"]
+            environment: entry["environment"], opaque_identity: entry["opaque_identity"]
           }
         end