rails_error_dashboard 0.14.0 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15c3e5f83e8ce2990ce4649cd7c71be0542ca7149863a6bc85ff8505d5ee0a4d
-  data.tar.gz: ccd0115a385bfbfeab743f6e84a4ff77875f449a0adfc16c54b2fa0e21f43029
+  metadata.gz: 93c0e9e0f21298eb85db1d661793709d60158c5f2c6f85b164da36b4593525ee
+  data.tar.gz: 37bae1ddaca2d502e434e0b4e6e95f6c755619598dec20f08495ce13fd0c286a
 SHA512:
-  metadata.gz: 972ecd630a40e2aa58dc33e22492acafb4910310a078a6172458796b6073420a27f773e6709004bd6172eabc6db1acd0de9128f345fa3931a905ea59592e591b
-  data.tar.gz: a1b25a254a0154f94f260054ddcf7cedaf08039f4f62b234270eb9b7c0ffa84d03d0e09fb0213f7c53aa143200aa6edcfcd4916d54eb8495b6dcb375b8dca2c7
+  metadata.gz: 9c6be20b1be293c069516ed0f5f6fc19e46203224bb9aaad6be1c645f45ebb3455e03e6b3fef8d8738e4cc658dc928cd56c9f2d403d270ec6caaaa74411074b7
+  data.tar.gz: 7c1c344be4398b47faf98de6a9be675f41a86878b49404d76b73d1a5be91f046ded677c70ebb9c1f4118e8736873ea491edcfed07b6520465049b9ecb3e1066b

data/app/controllers/rails_error_dashboard/application_controller.rb

@@ -314,6 +314,15 @@ module RailsErrorDashboard
         expected_password = RailsErrorDashboard.configuration.dashboard_password
         next false if expected_username.nil? || expected_password.nil?
 
+        # A blank credential must deny everyone too: "" would equal an empty login.
+        next false if RailsErrorDashboard::Configuration.blank_credential?(expected_username) ||
+                      RailsErrorDashboard::Configuration.blank_credential?(expected_password)
+
+        # The boot check refuses the published credentials outside development
+        # and test, but it is skipped while SECRET_KEY_BASE_DUMMY is set. Refuse
+        # them here as well, so that variable left set at runtime reopens nothing.
+        next false if RailsErrorDashboard.configuration.refuse_default_credentials?
+
         # Non-short-circuit & on purpose: both comparisons always run, so the
         # response time does not reveal which half was wrong.
         ActiveSupport::SecurityUtils.secure_compare(username.to_s, expected_username.to_s) &

data/config/locales/ja.yml

@@ -23,7 +23,7 @@ ja:
         '30': 30日間
         '90': 90日間
       frame_category:
-        app: 自分のコード
+        app: アプリケーションコード
         gem: Gem
         framework: Rails フレームワーク
         ruby_core: Ruby コア
@@ -520,7 +520,7 @@ ja:
         user_agent: 'User Agent:'
         ip_address: 'IP アドレス:'
         replay: 'リクエストの再現:'
-        raw_user_agent: User Agent の生データ
+        raw_user_agent: User Agent 文字列
         duration_seconds: "%{value}秒"
         duration_ms: "%{value}ミリ秒"
         copy_curl: curl としてコピー
@@ -530,7 +530,7 @@ ja:
         snapshot: 'スナップショット:'
         snapshot_captured_html: '%{time} に取得'
         snapshot_stale: より前の発生から取得 — それ以降の発生はコンテキストを伴いませんでした
-        snapshot_fidelity_lite: 縮小された取得 (storm 保護によりコンテキストの payload が破棄されました)
+        snapshot_fidelity_lite: 限定的な情報取得（storm 保護によりコンテキストの payload を省略）
         snapshot_fidelity_minimal: storm 中にカウントされました — コンテキストは取得されていません
         snapshot_fidelity_partial: 混在したスナップショット — 一部のフィールドは以前の発生時のものです
         snapshot_unknown: RED がスナップショットの出所を記録する前に取得されました
@@ -667,10 +667,10 @@ ja:
           backtrace: Backtrace
         backtrace:
           label: 'Backtrace:'
-          frame_counts: "(自分のコード%{app}件、フレームワーク/gem %{framework}件)"
+          frame_counts: "(アプリケーションコード%{app}件、フレームワーク/gem %{framework}件)"
           copy_full: Backtrace 全体をコピー
           copy_full_title: Backtrace 全体をコピー
-          your_code: 自分のコード
+          your_code: アプリケーションコード
           framework_code: フレームワーク・gem のコード
           frames:
             other: "%{count}フレーム"

data/lib/rails_error_dashboard/configuration.rb

@@ -2,6 +2,12 @@
 
 module RailsErrorDashboard
   class Configuration
+    # The built-in Basic auth credentials. They are published (README, demo,
+    # gemspec), so outside development and test they are refused unless
+    # ERROR_DASHBOARD_PASSWORD explicitly supplies the password.
+    DEFAULT_DASHBOARD_USERNAME = "gandalf"
+    DEFAULT_DASHBOARD_PASSWORD = "youshallnotpass"
+
     # Dashboard authentication (always required)
     attr_accessor :dashboard_username
     attr_accessor :dashboard_password
@@ -269,8 +275,8 @@ module RailsErrorDashboard
 
     def initialize
       # Default values - Authentication is ALWAYS required
-      @dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "gandalf")
-      @dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", "youshallnotpass")
+      @dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", DEFAULT_DASHBOARD_USERNAME)
+      @dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", DEFAULT_DASHBOARD_PASSWORD)
       @authenticate_with = nil
 
       @user_model = nil  # Auto-detect if not set
@@ -536,12 +542,16 @@ module RailsErrorDashboard
       # (GHSA-qhgm-3pxf-mvc6). Every future environment name a team invents is
       # now refused by default and has to be added here on purpose.
       #
-      # Skip during asset precompilation (SECRET_KEY_BASE_DUMMY=1) — ENV vars aren't available at build time
-      if default_credentials? &&
-         defined?(Rails) && Rails.respond_to?(:env) &&
-         !Rails.env.development? && !Rails.env.test? &&
-         ENV["SECRET_KEY_BASE_DUMMY"].blank?
-        errors << "Default or blank credentials cannot be used in #{Rails.env}. Only development and test may run on the built-in credentials. Set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD environment variables, or use authenticate_with for custom auth."
+      # Skip during asset precompilation (SECRET_KEY_BASE_DUMMY=1) — ENV vars aren't available at build time.
+      # The login refuses the same credentials on its own, so SECRET_KEY_BASE_DUMMY
+      # left set at runtime does not reopen them.
+      if refuse_default_credentials? && ENV["SECRET_KEY_BASE_DUMMY"].blank?
+        reason = if credentials_problem == :blank
+          "the dashboard username or password is blank"
+        else
+          "the dashboard password is the published default and was not set by ERROR_DASHBOARD_PASSWORD"
+        end
+        errors << "Default or blank credentials cannot be used in #{Rails.env}: #{reason}. Only development and test may run on the built-in credentials. Set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD environment variables and make sure the initializer does not overwrite them, or use authenticate_with for custom auth."
       end
 
       # Validate sampling_rate (must be between 0.0 and 1.0)
@@ -925,23 +935,65 @@ module RailsErrorDashboard
       list.empty? ? nil : list
     end
 
-    # Check if using default or blank demo credentials with basic auth
+    # Why the Basic auth credentials cannot be trusted outside development and
+    # test, or nil when they can.
     #
-    # Returns false if the user explicitly set ENV vars (even to the same default values),
-    # because that's a deliberate choice. Only blocks when credentials are untouched defaults
-    # or blank.
+    # - :blank - the username or password is empty or whitespace. An explicitly
+    #   empty variable is not a choice: a compose file passing an unset variable
+    #   through produces exactly that, and "" would match an empty login.
+    # - :published_password - the password is the published default and did not
+    #   come from ERROR_DASHBOARD_PASSWORD. Setting that variable, even to the
+    #   default, is a deliberate choice (the live demo runs that way). It has to
+    #   be THAT variable: setting only ERROR_DASHBOARD_USER used to leave the
+    #   password on the published default, and an initializer can hardcode it.
     #
-    # @return [Boolean] true if basic auth is active with untouched default or blank credentials
-    def default_credentials?
-      return false unless authenticate_with.nil?
+    # Both compare values the way the login does, with to_s: a Symbol holding the
+    # published password logs in just the same.
+    #
+    # @return [Symbol, nil]
+    def credentials_problem
+      return :blank if self.class.blank_credential?(dashboard_username) ||
+                       self.class.blank_credential?(dashboard_password)
+
+      if dashboard_password.to_s == DEFAULT_DASHBOARD_PASSWORD &&
+         ENV["ERROR_DASHBOARD_PASSWORD"] != DEFAULT_DASHBOARD_PASSWORD
+        return :published_password
+      end
 
-      # If user explicitly set ENV vars, respect their choice
-      return false if ENV.key?("ERROR_DASHBOARD_USER") || ENV.key?("ERROR_DASHBOARD_PASSWORD")
+      nil
+    end
 
-      default = dashboard_username == "gandalf" && dashboard_password == "youshallnotpass"
-      blank = dashboard_username.to_s.strip.empty? || dashboard_password.to_s.strip.empty?
+    # True for a credential that cannot be a secret: nil, empty, or only
+    # whitespace, including Unicode whitespace such as a no-break space, which
+    # String#strip leaves in place. The boot check and the login both use it.
+    #
+    # @return [Boolean]
+    def self.blank_credential?(value)
+      value.to_s.blank?
+    end
+
+    # Check if basic auth is active with blank credentials or the published
+    # default password (see #credentials_problem)
+    #
+    # Basic auth is active whenever authenticate_with is falsy, not only nil:
+    # the login falls back to it for `false` too, which is what
+    # `Rails.env.production? && -> { ... }` evaluates to in staging.
+    #
+    # @return [Boolean]
+    def default_credentials?
+      !authenticate_with && !credentials_problem.nil?
+    end
+
+    # True where default_credentials? has to stop the dashboard: anywhere that is
+    # not local development or test. The boot check and the login both use it,
+    # so the login still refuses when the boot check was skipped.
+    #
+    # @return [Boolean]
+    def refuse_default_credentials?
+      return false unless default_credentials?
+      return false unless defined?(Rails) && Rails.respond_to?(:env)
 
-      default || blank
+      !Rails.env.development? && !Rails.env.test?
     end
 
     # Resolve the effective issue tracker provider (auto-detect from git_repository_url).

data/lib/rails_error_dashboard/queries/error_correlation.rb

@@ -224,16 +224,14 @@ module RailsErrorDashboard
         previous_start = @start_date
         previous_end = current_start
 
-        # Both periods come from base_query, which carries the application
-        # filter (and the window start). Querying ErrorLog directly made this
-        # the one panel on an application-filtered page that counted every app.
-        current_errors = base_query
-          .where("occurred_at >= ?", current_start)
-          .count
-
-        previous_errors = base_query
-          .where("occurred_at < ?", previous_end)
-          .count
+        # EVENTS in each period, counted where they happened, over app_scope
+        # (which carries the application filter -- querying ErrorLog directly
+        # once made this the one panel that counted every app). Counting groups
+        # BORN in each period measured how many new errors appeared, not whether
+        # the application errors more or less: a chronic error that fired all
+        # month counted as zero in both halves.
+        current_errors = Queries::EventVolume.in_window(app_scope, current_start)
+        previous_errors = Queries::EventVolume.in_window(app_scope, previous_start, previous_end)
 
         change_percentage = if previous_errors > 0
           ((current_errors - previous_errors).to_f / previous_errors * 100).round(1)
@@ -261,25 +259,28 @@ module RailsErrorDashboard
       # Get top error types by platform
       # Shows which errors are platform-specific vs cross-platform
       # @return [Hash] Platform => top error types
+      #
+      # EVENT ranking: each platform's error types by their events in the
+      # window, and `also_on` from where else that type had events. Counting
+      # groups first seen in the window left out every chronic error, and
+      # ranked a type with many one-off groups above one that fired all day.
       def platform_specific_errors
-        platforms = base_query.distinct.pluck(:platform).compact
+        platforms = app_scope.distinct.pluck(:platform).compact
+        counts_by_platform = platforms.index_with do |platform|
+          Queries::EventVolume.by_group_attribute(app_scope.where(platform: platform), :error_type, @start_date)
+                              .select { |_, count| count.positive? }
+        end
+
+        counts_by_platform.each_with_object({}) do |(platform, counts_by_type), result|
+          next if counts_by_type.empty?
 
-        platforms.each_with_object({}) do |platform, result|
-          platform_errors = base_query.where(platform: platform)
-          top_errors = platform_errors
-            .group(:error_type)
-            .count
-            .sort_by { |_, count| -count }
-            .first(5)
+          top_errors = counts_by_type.sort_by { |error_type, count| [ -count, error_type.to_s ] }.first(5)
 
           result[platform] = top_errors.map do |error_type, count|
-            # Check if this error occurs on other platforms
-            other_platforms = base_query
-              .where(error_type: error_type)
-              .where.not(platform: platform)
-              .distinct
-              .pluck(:platform)
-              .compact
+            # Other platforms where this type had events in the window
+            other_platforms = counts_by_platform
+              .select { |other, other_counts| other != platform && other_counts.key?(error_type) }
+              .keys
 
             {
               error_type: error_type,
@@ -293,12 +294,20 @@ 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. Release attribution (errors by
+      # version / git SHA) is first-seen by design, so those figures use this.
+      def base_query
+        app_scope.where("occurred_at >= ?", @start_date)
+      end
+
       # Check if app_version column exists
       def has_version_column?
         ErrorLog.column_names.include?("app_version")

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/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

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.14.0"
+  VERSION = "0.14.2"
 end

data/lib/tasks/error_dashboard.rake

@@ -171,14 +171,19 @@ namespace :error_dashboard do
     if config.authenticate_with
       puts "OK (custom authentication)"
       checks_passed += 1
-    elsif config.dashboard_username == "gandalf" && config.dashboard_password == "youshallnotpass"
-      if Rails.env.production?
-        puts "WARNING - using default credentials in production!"
+    elsif (problem = config.credentials_problem)
+      # Same rule and environment allowlist as the boot check in validate!
+      label = problem == :blank ? "blank credentials" : "default credentials"
+      if config.refuse_default_credentials?
+        puts "WARNING - #{label} outside development and test!"
         checks_failed += 1
       else
-        puts "OK (default credentials - change before production)"
+        puts "OK (#{label} - change before production)"
         warnings += 1
       end
+    elsif config.dashboard_password == RailsErrorDashboard::Configuration::DEFAULT_DASHBOARD_PASSWORD
+      puts "OK (the published default password, set explicitly by ERROR_DASHBOARD_PASSWORD)"
+      warnings += 1
     else
       puts "OK (custom credentials)"
       checks_passed += 1

metadata

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