rails_error_dashboard 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c23f8c75c71f71913d2f5964f25a38642373f2f720e8996377a5877e54a1e6a
-  data.tar.gz: 95e1db7a2687ed2900e3a02a2f33d1a1c21fc70c4597f9d9bf5d5855356d2f98
+  metadata.gz: d504b1e375f3af3cb25e5fd636730f1f6e71cc74f98f9c2608bbd7ac042e1575
+  data.tar.gz: e6e8e5a078803978e9a93d5f0b2c71e6ec3a1b2ae7ee9c97fb4693a8f339ea98
 SHA512:
-  metadata.gz: acb081a03269304c9c70b63ee996bd8d446a525bd506f401851d8249ad9bffe2ead0bf63798be64c231604176e03c614c761e4f551b9827802b7881b99f3b1b0
-  data.tar.gz: d28393ca63c1b9639daeb2409cdc3f20074f905e1cbc9e3a89ae7b881dbe2666bfbaf53052d1172803de0ca46d58ff7ae8b4bd6f4d9b24be3ffa61ae1283a20e
+  metadata.gz: 3f64b74befa82818242fe0b38e1c399b2a683e0f464b6533fe62c9eac4de7503d9c18db124b05ddadedbfc3347c1edaddd49edfd845ff2a9eff8f5e2ddc68b45
+  data.tar.gz: 42e42075a4b4375fb71e8efe6eb6d85585a6c176c160ede254d1e4a937d8501fc102f40cacf74c9737745a6ca1700c6568d8986d7c78ed327a31008f0ce6522e

data/app/views/rails_error_dashboard/errors/analytics.html.erb

@@ -295,6 +295,12 @@
         <div class="card">
           <div class="card-header">
             <h5 class="mb-0"><i class="bi bi-people"></i> <%= red_t("red.analytics.overview.top_users.title") %></h5>
+            <%# Storm protection sheds per-event rows, and this table is built
+                from them, so the counts are a floor when that happened. The
+                Overview labels the same condition with the same key. %>
+            <% if @error_stats[:affected_users_incomplete] %>
+              <small style="display: block; color: var(--text-tertiary);"><%= red_t("red.errors.overview_page.affected_users_incomplete") %></small>
+            <% end %>
           </div>
           <div class="card-body p-0">
             <%= render partial: 'user_errors_table',

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -64,29 +64,45 @@ module RailsErrorDashboard
         base_scope.where("occurred_at >= ?", @start_date)
       end
 
+      # Two counting units, kept distinct on purpose.
+      #
+      # An ErrorLog row is a GROUP; its occurrence_count says how many times
+      # that error actually happened. Volume figures are EVENTS (the sum), so
+      # this page agrees with the Overview, which counts the same way. Resolved
+      # and unresolved stay GROUP counts -- a group is the thing that gets
+      # resolved, and an event cannot be.
       def error_statistics
         {
-          total: base_query.count,
+          total: event_count,
+          total_groups: base_query.count,
           unresolved: base_query.unresolved.count,
-          by_type: base_query.group(:error_type).count.sort_by { |_, count| -count }.to_h,
-          by_day: base_query.group("DATE(occurred_at)").count
+          resolved: base_query.resolved.count,
+          by_type: base_query.group(:error_type).sum(:occurrence_count).sort_by { |_, count| -count }.to_h,
+          by_day: base_query.group("DATE(occurred_at)").sum(:occurrence_count),
+          affected_users_incomplete: affected_users_incomplete?
         }
       end
 
+      # Total EVENTS in the window. dashboard_stats.rb and
+      # platform_comparison.rb:165 count the same way.
+      def event_count
+        base_query.sum(:occurrence_count)
+      end
+
       def errors_over_time
-        base_query.group_by_day(:occurred_at).count
+        base_query.group_by_day(:occurred_at).sum(:occurrence_count)
       end
 
       def errors_by_type
         base_query.group(:error_type)
-                  .count
+                  .sum(:occurrence_count)
                   .sort_by { |_, count| -count }
                   .first(10)
                   .to_h
       end
 
       def errors_by_platform
-        base_query.group(:platform).count
+        base_query.group(:platform).sum(:occurrence_count)
       end
 
       # NULL (captured before the column existed) is reported under :unknown
@@ -94,25 +110,81 @@ module RailsErrorDashboard
       def errors_by_environment
         return {} unless ErrorLog.column_names.include?("environment")
 
-        base_query.group(:environment).count.transform_keys { |env| env.nil? ? :unknown : env }
+        base_query.group(:environment).sum(:occurrence_count).transform_keys { |env| env.nil? ? :unknown : env }
       end
 
       def errors_by_hour
         # group_by_hour_of_day buckets into 0..23 to show diurnal patterns
         # (when in the day errors peak). The chart title says "Errors by Hour
         # of Day" — group_by_hour produced a chronological time series instead.
-        base_query.group_by_hour_of_day(:occurred_at).count
+        base_query.group_by_hour_of_day(:occurred_at).sum(:occurrence_count)
       end
 
+      # Events per user, counted from OCCURRENCE rows.
+      #
+      # The group's user_id is overwritten by each new occurrence, so grouping
+      # ErrorLog by it attributed a whole group to whoever happened to hit it
+      # last -- at most one user per group, and their "count" was a number of
+      # groups. Occurrence rows carry the user of each individual event.
+      #
+      # Storm count-only events create no occurrence row, so during a storm
+      # this is a floor; affected_users_incomplete? says when.
       def top_affected_users
         user_model = RailsErrorDashboard.configuration.user_model
 
-        base_query.where.not(user_id: nil)
-                  .group(:user_id)
-                  .count
-                  .sort_by { |_, count| -count }
-                  .first(10)
-                  .map { |user_id, count| { user_id: user_id, email: find_user_email(user_id, user_model), count: count } }
+        counts = user_event_counts
+        counts.sort_by { |_, count| -count }
+              .first(10)
+              .map { |user_id, count| { user_id: user_id, email: find_user_email(user_id, user_model), count: count } }
+      end
+
+      def user_event_counts
+        return group_user_counts unless occurrences_available?
+
+        occurrences = ErrorOccurrence.table_name
+        counts = occurrence_scope.where("#{occurrences}.occurred_at >= ?", @start_date)
+                                 .where.not(occurrences => { user_id: nil })
+                                 .group("#{occurrences}.user_id")
+                                 .count
+
+        # A user whose events predate occurrence tracking -- or whose events
+        # were shed by storm protection, which writes no occurrence row -- still
+        # belongs in the table. Fall back to the group's own user for those,
+        # taking whichever count is larger. UserImpactSummary merges the same way.
+        group_user_counts.merge(counts) { |_user, group_count, occurrence_count| [ group_count, occurrence_count ].max }
+      rescue StandardError
+        group_user_counts
+      end
+
+      def group_user_counts
+        base_query.where.not(user_id: nil).group(:user_id).sum(:occurrence_count)
+      end
+
+      # Occurrence rows joined back to error_logs, so the application filter
+      # (which the occurrence table has no column for) still applies.
+      def occurrence_scope
+        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 holds more events than recorded occurrences --
+      # storm shedding dropped per-event rows, so any occurrence-derived
+      # figure (the affected-user table) is a floor, not a total.
+      def affected_users_incomplete?
+        return false unless occurrences_available?
+
+        occurrences = ErrorOccurrence.table_name
+        recorded = occurrence_scope.where("#{occurrences}.occurred_at >= ?", @start_date).count
+        recorded < event_count
+      rescue StandardError
+        false
       end
 
       def find_user_email(user_id, user_model)
@@ -122,23 +194,31 @@ module RailsErrorDashboard
         "User ##{user_id}"
       end
 
+      # Resolution rate is GROUPS over GROUPS.
+      #
+      # Volume is now measured in events, but resolving is something that
+      # happens to a group, so dividing resolved groups by total events would
+      # collapse the rate toward zero the moment any error recurred. The
+      # Overview computes this the same way (resolved / resolved + unresolved),
+      # so both pages report one rate.
+      #
+      # Same scoped relation on both sides: an unscoped numerator counted every
+      # application's resolved errors against one application's total, and the
+      # "rate" went past 100%.
       def resolution_rate
-        total = error_statistics[:total]
-        return 0 if total.zero?
-
-        # Same scoped relation as the denominator: an unscoped numerator
-        # counted every application's resolved errors against one
-        # application's total, and the "rate" went past 100%.
         resolved_count = base_query.resolved.count
-        ((resolved_count.to_f / total) * 100).round(1)
+        total_groups = resolved_count + base_query.unresolved.count
+        return 0 if total_groups.zero?
+
+        ((resolved_count.to_f / total_groups) * 100).round(1)
       end
 
       def mobile_errors_count
-        base_query.where(platform: [ "iOS", "Android" ]).count
+        base_query.where(platform: [ "iOS", "Android" ]).sum(:occurrence_count)
       end
 
       def api_errors_count
-        base_query.where("platform IS NULL OR platform = ?", "API").count
+        base_query.where("platform IS NULL OR platform = ?", "API").sum(:occurrence_count)
       end
 
       #  Pattern insights for top error types

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.12.0"
+  VERSION = "0.12.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.12.1
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -585,7 +585,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.12.0
+    RED (Rails Error Dashboard) v0.12.1
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install: