rails_error_dashboard 0.13.0 → 0.14.1

data/lib/rails_error_dashboard/queries/platform_comparison.rb

@@ -12,6 +12,24 @@ module RailsErrorDashboard
     # - Platform stability scores
     # - Cross-platform errors
     #
+    # Two counting units, kept distinct on purpose -- the same split as
+    # AnalyticsStats, for the same reason.
+    #
+    #   EVENT figures  -> Queries::EventVolume: how much erroring happened in
+    #                     the window. Error rate, daily trend, severity
+    #                     distribution, cross-platform totals, the top-errors
+    #                     ranking, and the health card's total, critical count
+    #                     and velocity.
+    #   GROUP figures  -> groups FIRST SEEN in the window: the state of
+    #                     distinct errors. Unresolved count, resolution rate and
+    #                     resolution time. A group is what gets resolved; an
+    #                     event cannot be.
+    #
+    # An ErrorLog row is a GROUP and its occurred_at is FIRST-SEEN. Selecting
+    # groups by it and counting them made a group born last month that recurs
+    # today invisible here -- zero errors on this page (and on the Overview's
+    # platform health card) while the Overview's own total counted the event.
+    #
     # @example
     #   comparison = PlatformComparison.new(days: 7)
     #   comparison.error_rate_by_platform
@@ -29,7 +47,9 @@ module RailsErrorDashboard
 
       private
 
-      # Base scope that filters by application when present
+      # Every group of the selected application, NOT cut by date. EventVolume
+      # must be handed this: a scope already filtered by first-seen drops the
+      # events of every older group that recurred inside the window.
       # @return [ActiveRecord::Relation]
       def base_scope
         scope = ErrorLog.all
@@ -37,38 +57,47 @@ module RailsErrorDashboard
         scope
       end
 
+      def platforms
+        @platforms ||= base_scope.distinct.pluck(:platform).compact
+      end
+
+      def volume
+        @volume ||= Queries::EventVolume.new(base_scope, @start_date)
+      end
+
+      # platform => { error_type => events in the window }.
+      #
+      # Severity, critical counts and cross-platform totals all fold from this
+      # one breakdown, so they cannot drift from each other, and each platform's
+      # parts sum to its error rate (the same primitive, exhaustively grouped).
+      def type_volume_by_platform
+        @type_volume_by_platform ||= platforms.index_with do |platform|
+          Queries::EventVolume.by_group_attribute(base_scope.where(platform: platform), :error_type, @start_date)
+        end
+      end
+
       public
 
-      # Get error count by platform for the time period
-      # @return [Hash] Platform name => error count
+      # Events per platform in the window.
+      # @return [Hash] Platform name => event count
       def error_rate_by_platform
-        base_scope
-          .where("occurred_at >= ?", @start_date)
-          .group(:platform)
-          .count
+        # select, not the raw breakdown: that is a Hash.new(0), and a platform
+        # with no events must read as absent (nil), not as a silent zero.
+        @error_rate_by_platform ||= volume.by_group_attribute(:platform).select { |_, count| count.positive? }
       end
 
-      # Get severity distribution by platform
+      # Events per platform, by severity of their error type.
       # @return [Hash] Platform => { severity => count }
       def severity_distribution_by_platform
-        platforms = base_scope.distinct.pluck(:platform).compact
-
-        platforms.each_with_object({}) do |platform, result|
-          errors = base_scope
-            .where(platform: platform)
-            .where("occurred_at >= ?", @start_date)
-
-          # Calculate severity in Ruby since it's a method, not a column
-          severity_counts = Hash.new(0)
-          errors.each do |error|
-            severity_counts[error.severity] += 1
+        type_volume_by_platform.transform_values do |counts_by_type|
+          counts_by_type.each_with_object(Hash.new(0)) do |(error_type, count), severities|
+            severities[Services::SeverityClassifier.classify(error_type)] += count
           end
-
-          result[platform] = severity_counts
         end
       end
 
       # Get average resolution time by platform
+      # GROUP figure: a resolution belongs to a group, selected by first-seen.
       # @return [Hash] Platform => average hours to resolve
       def resolution_time_by_platform
         platforms = base_scope.distinct.pluck(:platform).compact
@@ -90,28 +119,38 @@ module RailsErrorDashboard
         end
       end
 
-      # Get top 10 errors for each platform
+      # Top 10 groups per platform, ranked by their events in the window.
+      #
+      # :occurrence_count is the group's count WITHIN the window, not its
+      # lifetime total -- the key is kept so the view and callers are
+      # unchanged. The per-group breakdown holds one integer pair per group
+      # with events in the window; only the top ten rows are loaded.
       # @return [Hash] Platform => Array of error hashes
       def top_errors_by_platform
-        platforms = base_scope.distinct.pluck(:platform).compact
-
         platforms.each_with_object({}) do |platform, result|
-          result[platform] = base_scope
-            .where(platform: platform)
-            .where("occurred_at >= ?", @start_date)
-            .select(:id, :error_type, :message, :occurrence_count, :occurred_at)
-            .order(occurrence_count: :desc)
-            .limit(10)
-            .map do |error|
-              {
-                id: error.id,
-                error_type: error.error_type,
-                message: error.message&.truncate(100),
-                severity: error.severity, # Calls the method
-                occurrence_count: error.occurrence_count,
-                occurred_at: error.occurred_at
-              }
-            end
+          events_by_group = Queries::EventVolume.by_group_attribute(
+            base_scope.where(platform: platform), :id, @start_date
+          )
+          top = events_by_group.select { |_, count| count.positive? }
+                               .sort_by { |id, count| [ -count, id ] }
+                               .first(10)
+          groups = ErrorLog.where(id: top.map(&:first))
+                           .select(:id, :error_type, :message, :occurred_at)
+                           .index_by(&:id)
+
+          result[platform] = top.filter_map do |id, count|
+            error = groups[id]
+            next unless error
+
+            {
+              id: error.id,
+              error_type: error.error_type,
+              message: error.message&.truncate(100),
+              severity: error.severity, # Calls the method
+              occurrence_count: count,
+              occurred_at: error.occurred_at
+            }
+          end
         end
       end
 
@@ -141,98 +180,70 @@ module RailsErrorDashboard
         end
       end
 
-      # Find errors that occur across multiple platforms
+      # Error types with events on more than one platform in the window.
       # @return [Array<Hash>] Errors with their platforms
       def cross_platform_errors
-        # Get error types that appear on 2+ platforms
-        error_types_with_platforms = base_scope
-          .where("occurred_at >= ?", @start_date)
-          .group(:error_type, :platform)
-          .select(:error_type, :platform)
-          .having("COUNT(*) > 0")
-          .pluck(:error_type, :platform)
-
-        # Group by error_type to find those on multiple platforms
-        errors_by_type = error_types_with_platforms.group_by { |error_type, _| error_type }
-
-        errors_by_type
-          .select { |_, platforms| platforms.map(&:last).uniq.count > 1 }
-          .map do |error_type, platform_pairs|
-            platforms = platform_pairs.map(&:last).uniq
-            total_count = base_scope
-              .where(error_type: error_type, platform: platforms)
-              .where("occurred_at >= ?", @start_date)
-              .sum(:occurrence_count)
+        by_type = Hash.new { |hash, error_type| hash[error_type] = {} }
+        type_volume_by_platform.each do |platform, counts_by_type|
+          counts_by_type.each do |error_type, count|
+            by_type[error_type][platform] = count if count.positive?
+          end
+        end
 
+        by_type
+          .select { |_, breakdown| breakdown.size > 1 }
+          .map do |error_type, breakdown|
             {
               error_type: error_type,
-              platforms: platforms.sort,
-              total_occurrences: total_count,
-              platform_breakdown: platforms.each_with_object({}) do |platform, breakdown|
-                breakdown[platform] = base_scope
-                  .where(error_type: error_type, platform: platform)
-                  .where("occurred_at >= ?", @start_date)
-                  .sum(:occurrence_count)
-              end
+              platforms: breakdown.keys.sort,
+              total_occurrences: breakdown.values.sum,
+              platform_breakdown: breakdown
             }
           end
           .sort_by { |error| -error[:total_occurrences] }
       end
 
-      # Get daily error trend by platform
+      # Events per day per platform, on the day each event HAPPENED.
+      #
+      # The zero-filled date range is preserved: the chart needs a point for
+      # every day in the window, not only the days that had errors.
       # @return [Hash] Platform => { date => count }
       def daily_trend_by_platform
-        platforms = base_scope.distinct.pluck(:platform).compact
+        days = (@start_date.to_date..Date.current)
 
-        platforms.each_with_object({}) do |platform, result|
-          result[platform] = base_scope
-            .where(platform: platform)
-            .where("occurred_at >= ?", @start_date)
-            .group_by_day(:occurred_at, range: @start_date..Time.current)
-            .count
+        platforms.index_with do |platform|
+          counts = Queries::EventVolume.by_day(base_scope.where(platform: platform), @start_date)
+          days.to_h { |day| [ day, counts[day] || 0 ] }
         end
       end
 
       # Get platform health summary
       # @return [Hash] Platform => health metrics
       def platform_health_summary
-        platforms = base_scope.distinct.pluck(:platform).compact
         error_rates = error_rate_by_platform
         stability_scores = platform_stability_scores
+        severities = severity_distribution_by_platform
+        midpoint = @start_date + (@days / 2.0).days
 
         platforms.each_with_object({}) do |platform, result|
-          total_errors = error_rates[platform] || 0
-
-          # Count critical errors by checking severity method
-          critical_errors = base_scope
-            .where(platform: platform)
-            .where("occurred_at >= ?", @start_date)
-            .select { |error| error.severity == :critical }
-            .count
+          platform_scope = base_scope.where(platform: platform)
+          groups_in_window = platform_scope.where("occurred_at >= ?", @start_date)
 
-          unresolved_errors = base_scope
-            .where(platform: platform, resolved_at: nil)
-            .where("occurred_at >= ?", @start_date)
-            .count
-
-          resolved_errors = base_scope
-            .where(platform: platform)
-            .where.not(resolved_at: nil)
-            .where("occurred_at >= ?", @start_date)
-            .count
-
-          resolution_rate = total_errors.positive? ? ((resolved_errors.to_f / total_errors) * 100).round(1) : 0.0
-
-          # Calculate error velocity (increasing or decreasing)
-          first_half = base_scope
-            .where(platform: platform)
-            .where("occurred_at >= ? AND occurred_at < ?", @start_date, @start_date + (@days / 2.0).days)
-            .count
-
-          second_half = base_scope
-            .where(platform: platform)
-            .where("occurred_at >= ?", @start_date + (@days / 2.0).days)
-            .count
+          # EVENT figures: part of the same volume as the error rate.
+          total_errors = error_rates[platform] || 0
+          critical_errors = severities.fetch(platform, {})[:critical] || 0
+
+          # GROUP figures. The resolution rate divides groups by groups; divided
+          # by the event total it would mix units and stop meaning anything.
+          unresolved_errors = groups_in_window.where(resolved_at: nil).count
+          resolved_errors = groups_in_window.where.not(resolved_at: nil).count
+          total_groups = unresolved_errors + resolved_errors
+          resolution_rate = total_groups.positive? ? ((resolved_errors.to_f / total_groups) * 100).round(1) : 0.0
+
+          # Error velocity: events in the second half of the window against the
+          # first, each counted where it happened.
+          first_half = Queries::EventVolume.in_window(platform_scope, @start_date, midpoint)
+          second_half = Queries::EventVolume.in_window(platform_scope, midpoint)
 
           velocity = first_half.positive? ? (((second_half - first_half).to_f / first_half) * 100).round(1) : 0.0
 

data/lib/rails_error_dashboard/queries/recurring_issues.rb

@@ -5,6 +5,9 @@ module RailsErrorDashboard
     # Query: Analyze recurring and persistent errors
     # Returns data about high-frequency errors, persistent issues, and cyclical patterns
     class RecurringIssues
+      # Minimum events IN THE WINDOW for a group to count as high frequency.
+      HIGH_FREQUENCY_THRESHOLD = 10
+
       def self.call(days = 30, application_id: nil)
         new(days, application_id: application_id).call
       end
@@ -25,37 +28,53 @@ module RailsErrorDashboard
 
       private
 
-      def base_query
-        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+      # Every group of the application, NOT cut by date -- what EventVolume
+      # must be handed, or it never sees an older group's recurrences.
+      def app_scope
+        scope = ErrorLog.all
         scope = scope.where(application_id: @application_id) if @application_id.present?
         scope
       end
 
+      # Groups FIRST SEEN in the window, for the group lists below.
+      def base_query
+        app_scope.where("occurred_at >= ?", @start_date)
+      end
+
+      # EVENT figure: error types whose groups fired more than
+      # HIGH_FREQUENCY_THRESHOLD times in the window, by events in the window.
+      #
+      # Selecting groups by first-seen and summing their LIFETIME
+      # occurrence_count listed only errors born in the window -- a chronic
+      # error that fired all month was never "high frequency" once it was a
+      # month old. The threshold stays per group (not per type) so eleven
+      # one-off groups of one type do not qualify; it now counts this window.
       def high_frequency_errors
-        # Errors with high occurrence count
-        base_query
-          .where("occurrence_count > ?", 10)
-          .group(:error_type)
-          .select("error_type,
-                   SUM(occurrence_count) as total_occurrences,
-                   MIN(first_seen_at) as first_occurrence,
-                   MAX(last_seen_at) as last_occurrence,
-                   COUNT(*) as unique_error_count")
-          .order("total_occurrences DESC")
-          .limit(10)
-          .map do |error|
-            first_seen = error.first_occurrence.is_a?(Time) ? error.first_occurrence : Time.parse(error.first_occurrence.to_s)
-            last_seen = error.last_occurrence.is_a?(Time) ? error.last_occurrence : Time.parse(error.last_occurrence.to_s)
+        events_by_group = Queries::EventVolume.by_group_attribute(app_scope, :id, @start_date)
+                                              .select { |_, count| count > HIGH_FREQUENCY_THRESHOLD }
+        return [] if events_by_group.empty?
 
-            {
-              error_type: error.error_type,
-              total_occurrences: error.total_occurrences,
-              first_seen: first_seen,
-              last_seen: last_seen,
-              duration_days: ((last_seen - first_seen) / 1.day).round,
-              still_active: last_seen > 24.hours.ago
-            }
-          end
+        groups = ErrorLog.where(id: events_by_group.keys)
+                         .pluck(:id, :error_type, :first_seen_at, :last_seen_at, :occurred_at)
+
+        groups.group_by { |_, error_type, *| error_type }
+              .map do |error_type, rows|
+                # first_seen_at/last_seen_at are NULL on rows from before those
+                # columns; occurred_at is the only timestamp such a row has.
+                first_seen = rows.map { |_, _, first, _, occurred| first || occurred }.min
+                last_seen = rows.map { |_, _, _, last, occurred| last || occurred }.max
+
+                {
+                  error_type: error_type,
+                  total_occurrences: rows.sum { |id, *| events_by_group[id] },
+                  first_seen: first_seen,
+                  last_seen: last_seen,
+                  duration_days: ((last_seen - first_seen) / 1.day).round,
+                  still_active: last_seen > 24.hours.ago
+                }
+              end
+              .sort_by { |entry| [ -entry[:total_occurrences], entry[:error_type].to_s ] }
+              .first(10)
       end
 
       def persistent_errors

data/lib/rails_error_dashboard/queries/user_impact_summary.rb

@@ -29,30 +29,48 @@ module RailsErrorDashboard
 
       private
 
-      def base_scope
-        scope = ErrorLog.where("occurred_at >= ?", @start_date)
-                        .where.not(user_id: nil)
+      # Every group of the selected application, NOT cut by date. EventVolume
+      # and the row samples need this: an error first seen before the window
+      # that recurs inside it is still this window's error.
+      def app_scope
+        scope = ErrorLog.all
         scope = scope.where(application_id: @application_id) if @application_id.present?
         scope
       end
 
+      # Groups FIRST SEEN in the window with a user -- the group-level fallback
+      # for errors whose events predate occurrence tracking (see
+      # distinct_users_by_type).
+      def base_scope
+        app_scope.where("occurred_at >= ?", @start_date).where.not(user_id: nil)
+      end
+
       def build_entries
         # 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)
-          .sum(:occurrence_count)
+        # EVENTS per type in the window, each counted where it happened --
+        # occurrence rows, storm-shed buckets and the untracked remainder.
+        # Summing the lifetime occurrence_count of groups born in the window
+        # gave an August error recurring today zero occurrences on a row that
+        # still listed its users.
+        occurrence_counts = Queries::EventVolume.by_group_attribute(app_scope, :error_type, @start_date)
 
         total_users = effective_total_users
 
         user_counts.map do |error_type, unique_users|
           occurrences = occurrence_counts[error_type] || 0
-          sample = base_scope.where(error_type: error_type).order(occurred_at: :desc).first
+          # The row's message, severity and link: the most recently seen group
+          # of this type. Taken from app_scope for the same reason as the
+          # counts -- a first-seen scope has no sample for an older error, and
+          # the row rendered with no message and nothing to click.
+          # COALESCE, not a bare last_seen_at DESC: PostgreSQL sorts NULLs
+          # FIRST in descending order, so a row from before the column existed
+          # would outrank every live one there.
+          sample = app_scope.where(error_type: error_type).where.not(user_id: nil)
+                            .order(Arel.sql("COALESCE(last_seen_at, occurred_at) DESC"), id: :desc).first
           impact_pct = total_users && total_users > 0 ? (unique_users.to_f / total_users * 100).round(1) : nil
 
           {
@@ -62,7 +80,8 @@ module RailsErrorDashboard
             total_occurrences: occurrences,
             impact_percentage: impact_pct,
             severity: sample&.severity,
-            last_seen: sample&.occurred_at,
+            # "Last Seen" -- occurred_at is FIRST-seen and never moves.
+            last_seen: sample&.last_seen_at || sample&.occurred_at,
             id: sample&.id
           }
         end.sort_by { |e| -e[:unique_users] }

data/lib/rails_error_dashboard/services/breadcrumb_collector.rb

@@ -77,6 +77,29 @@ module RailsErrorDashboard
         nil
       end
 
+      # Open a buffer ONLY if this thread has none, and say whether we opened
+      # it. The caller passes that answer back to clear_buffer_if_owned, so a
+      # job performed inline inside a request adds its crumbs to the request's
+      # trail and does not tear it down on the way out.
+      #
+      # Unconditional init/clear here would erase a surrounding request's
+      # buffer on every perform_now, the test adapter and the :inline queue.
+      # @return [Boolean] true when this caller opened the buffer
+      def self.init_buffer_unless_present
+        return false if Thread.current[THREAD_KEY]
+
+        init_buffer
+        true
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] BreadcrumbCollector.init_buffer_unless_present failed: #{e.message}")
+        false
+      end
+
+      # Tear down only what this caller opened (see init_buffer_unless_present).
+      def self.clear_buffer_if_owned(owned)
+        clear_buffer if owned
+      end
+
       # Clear the ring buffer (end of request — MUST be called in ensure block)
       def self.clear_buffer
         Thread.current[THREAD_KEY] = nil

data/lib/rails_error_dashboard/services/digest_builder.rb

@@ -56,17 +56,39 @@ module RailsErrorDashboard
         I18nStore.translate(PERIODS[@period][:label_key], locale: @locale)
       end
 
-      def base_scope
-        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+      # Two counting units, kept distinct on purpose (as in AnalyticsStats).
+      #
+      #   EVENT figures -> Queries::EventVolume over app_scope: how much
+      #                    erroring happened in the period. Occurrences, the
+      #                    top-errors counts and the period comparison.
+      #   GROUP figures -> base_scope, groups FIRST SEEN in the period: new,
+      #                    resolved, unresolved, critical/high, resolution rate
+      #                    and the critical-unresolved list.
+      #
+      # Summing the lifetime counts of groups born in the period reported an
+      # unresolved August error that fired all day today as zero occurrences,
+      # absent from Top Errors, with an empty comparison.
+
+      # Every group of the application, NOT cut by date -- what EventVolume
+      # must be handed, or it never sees an older group's recurrences.
+      def app_scope
+        scope = ErrorLog.all
         scope = scope.where(application_id: @application_id) if @application_id.present?
         scope
       end
 
+      def base_scope
+        app_scope.where("occurred_at >= ?", @start_date)
+      end
+
       def build_stats
         scope = base_scope
 
-        new_errors = scope.where("occurrence_count <= 1").count
-        total_occurrences = scope.sum(:occurrence_count)
+        # GROUP figure: errors first seen in the period, however often they
+        # fired. `occurrence_count <= 1` counted "seen once", so a brand-new
+        # error that fired twice was missing from the headline and the subject.
+        new_errors = scope.count
+        total_occurrences = Queries::EventVolume.in_window(app_scope, @start_date)
         resolved = scope.where(resolved: true).count
         unresolved = scope.where(resolved: false).count
         # Severity is computed from error_type via SeverityClassifier (not a DB column).
@@ -91,15 +113,21 @@ module RailsErrorDashboard
         { new_errors: 0, total_occurrences: 0, resolved: 0, unresolved: 0, critical_high: 0, resolution_rate: 0 }
       end
 
+      # Unresolved error types ranked by their events in the period. This used
+      # to count GROUPS per type (a type with five groups scored 5 however
+      # often each fired), and only groups born in the period.
       def top_errors
-        base_scope
-          .where(resolved: false)
-          .group(:error_type)
-          .order("count_all DESC")
-          .limit(5)
-          .count
+        unresolved = app_scope.where(resolved: false)
+
+        Queries::EventVolume.by_group_attribute(unresolved, :error_type, @start_date)
+          .select { |_, count| count.positive? }
+          .sort_by { |error_type, count| [ -count, error_type.to_s ] }
+          .first(5)
           .map do |error_type, count|
-            sample = base_scope.where(error_type: error_type).order(occurred_at: :desc).first
+            # Most recently seen first; COALESCE because PostgreSQL sorts NULLs
+            # first in descending order.
+            sample = unresolved.where(error_type: error_type)
+                               .order(Arel.sql("COALESCE(last_seen_at, occurred_at) DESC"), id: :desc).first
             {
               error_type: error_type,
               message: sample&.message.to_s.truncate(100),
@@ -137,10 +165,11 @@ module RailsErrorDashboard
         previous_start = (@days * 2).days.ago
         previous_end = @start_date
 
-        current_count = base_scope.count
-        previous_scope = ErrorLog.where("occurred_at >= ? AND occurred_at < ?", previous_start, previous_end)
-        previous_scope = previous_scope.where(application_id: @application_id) if @application_id.present?
-        previous_count = previous_scope.count
+        # Events in each period, counted where they happened. Counting groups
+        # born in each period measured how many NEW errors appeared, not
+        # whether the application is erroring more or less.
+        current_count = Queries::EventVolume.in_window(app_scope, @start_date)
+        previous_count = Queries::EventVolume.in_window(app_scope, previous_start, previous_end)
 
         delta = current_count - previous_count
         percentage = previous_count > 0 ? ((delta.to_f / previous_count) * 100).round(1) : nil