rails_error_dashboard 0.12.1 → 0.14.0

data/lib/rails_error_dashboard/commands/snooze_error.rb

@@ -4,7 +4,14 @@ module RailsErrorDashboard
   module Commands
     # Command: Snooze an error for a given number of hours
     # This is a write operation that sets snoozed_until and optionally creates a comment
+    # Returns {success: bool, error: ErrorLog}; a failure also carries
+    # reason: :invalid_hours and writes nothing.
     class SnoozeError
+      # 30 days. The form offers at most a week; the cap is for anything that
+      # does not come from the form. Without one, a negative value "snoozed"
+      # into the past and a huge one overflowed the timestamp.
+      MAX_SNOOZE_HOURS = 720
+
       def self.call(error_id, hours:, reason: nil)
         new(error_id, hours, reason).call
       end
@@ -17,18 +24,35 @@ module RailsErrorDashboard
 
       def call
         error = ErrorLog.find(@error_id)
-        snooze_until = @hours.hours.from_now
-
-        # Store snooze reason in comments if provided
-        if @reason.present?
-          error.comments.create!(
-            author_name: error.assigned_to || "System",
-            body: "Snoozed for #{@hours} hours: #{@reason}"
-          )
+        hours = whole_hours(@hours)
+
+        unless hours && (1..MAX_SNOOZE_HOURS).cover?(hours)
+          return { success: false, error: error, reason: :invalid_hours }
+        end
+
+        error.transaction do
+          if @reason.present?
+            error.comments.create!(
+              author_name: error.assigned_to || "System",
+              body: "Snoozed for #{hours} hours: #{@reason}"
+            )
+          end
+
+          error.update!(snoozed_until: hours.hours.from_now)
         end
 
-        error.update!(snoozed_until: snooze_until)
-        error
+        { success: true, error: error }
+      end
+
+      private
+
+      # An Integer, or a String that is one ("24"). Anything else -- a Float, a
+      # nested parameter, "abc" -- is nil rather than a guess.
+      def whole_hours(value)
+        case value
+        when Integer then value
+        when String then Integer(value.strip, 10, exception: false)
+        end
       end
     end
   end

data/lib/rails_error_dashboard/commands/unmute_error.rb

@@ -22,6 +22,7 @@ module RailsErrorDashboard
           muted_reason: nil
         )
 
+        Services::AnalyticsCacheManager.clear
         PluginRegistry.dispatch(:on_error_unmuted, error)
         error
       end

data/lib/rails_error_dashboard/commands/update_error_priority.rb

@@ -4,6 +4,8 @@ module RailsErrorDashboard
   module Commands
     # Command: Update the priority level of an error
     # This is a write operation that updates the priority_level field on an ErrorLog record
+    # Returns {success: bool, error: ErrorLog}; a failure also carries
+    # reason: :invalid_priority and leaves the existing priority alone.
     class UpdateErrorPriority
       def self.call(error_id, priority_level:)
         new(error_id, priority_level).call
@@ -16,8 +18,27 @@ module RailsErrorDashboard
 
       def call
         error = ErrorLog.find(@error_id)
-        error.update!(priority_level: @priority_level)
-        error
+        level = whole_number(@priority_level)
+
+        # The column is an integer, so an unchecked "x" was cast and stored as
+        # 0 -- silently replacing a real priority with Low.
+        unless ErrorLog::PRIORITY_LEVELS.key?(level)
+          return { success: false, error: error, reason: :invalid_priority }
+        end
+
+        error.update!(priority_level: level)
+        { success: true, error: error }
+      end
+
+      private
+
+      # An Integer, or a String that is one ("3"). A nested parameter, a Float
+      # or free text is nil.
+      def whole_number(value)
+        case value
+        when Integer then value
+        when String then Integer(value.strip, 10, exception: false)
+        end
       end
     end
   end

data/lib/rails_error_dashboard/commands/update_error_status.rb

@@ -4,7 +4,8 @@ module RailsErrorDashboard
   module Commands
     # Command: Update the status of an error with optional comment
     # This is a write operation that validates transitions and updates status
-    # Returns {success: bool, error: ErrorLog}
+    # Returns {success: bool, error: ErrorLog}; a failure also carries
+    # reason: :unknown_status or :invalid_transition so the caller can say which.
     class UpdateErrorStatus
       def self.call(error_id, status:, comment: nil)
         new(error_id, status, comment).call
@@ -19,15 +20,17 @@ module RailsErrorDashboard
       def call
         error = ErrorLog.find(@error_id)
 
+        # A nested param arrives as a Hash-like object, never a known status.
+        unless @status.is_a?(String) && ErrorLog::STATUSES.include?(@status)
+          return { success: false, error: error, reason: :unknown_status }
+        end
+
         unless error.can_transition_to?(@status)
-          return { success: false, error: error }
+          return { success: false, error: error, reason: :invalid_transition }
         end
 
         error.transaction do
-          error.update!(status: @status)
-
-          # Auto-resolve if status is "resolved"
-          error.update!(resolved: true) if @status == "resolved"
+          error.update!(status_attributes(error))
 
           # Add comment about status change
           if @comment.present?
@@ -38,8 +41,32 @@ module RailsErrorDashboard
           end
         end
 
+        # The stat cards are cached; a user action must show up at once.
+        Services::AnalyticsCacheManager.clear
+
         { success: true, error: error }
       end
+
+      private
+
+      # One write, so the three columns can never disagree. resolved_at is what
+      # MTTR is computed from: leaving it nil (as this command used to) dropped
+      # every error resolved through the status workflow from the MTTR figures,
+      # and leaving it set on a reopened error kept a stale resolution time.
+      # Only "resolved" sets the flag -- wont_fix stays resolved: false.
+      def status_attributes(error)
+        attrs = { status: @status }
+
+        if @status == "resolved"
+          attrs[:resolved] = true
+          attrs[:resolved_at] = Time.current
+        elsif error.status == "resolved" || error.resolved?
+          attrs[:resolved] = false
+          attrs[:resolved_at] = nil
+        end
+
+        attrs
+      end
     end
   end
 end

data/lib/rails_error_dashboard/configuration.rb

@@ -157,6 +157,8 @@ module RailsErrorDashboard
     attr_accessor :notification_minimum_severity   # Minimum severity to notify (default: :low = notify all)
     attr_accessor :notification_cooldown_minutes    # Per-error cooldown in minutes (default: 5, 0 = disabled)
     attr_accessor :notification_threshold_alerts    # Occurrence milestones that trigger notification (default: [10, 50, 100, 500, 1000])
+    attr_accessor :notification_burst_limit          # Max FIRST-OCCURRENCE notifications per window, per process (default: 10, 0 = no cap)
+    attr_accessor :notification_burst_window_seconds # Length of that window in seconds (default: 60)
 
     # Breadcrumbs (request activity trail)
     attr_accessor :enable_breadcrumbs              # Master switch (default: false)
@@ -180,6 +182,12 @@ module RailsErrorDashboard
     attr_accessor :local_variable_max_array_items     # Max array items to serialize (default: 10)
     attr_accessor :local_variable_max_hash_items      # Max hash entries to serialize (default: 20)
     attr_accessor :local_variable_filter_patterns     # Additional sensitive name patterns (default: [])
+    # Calling #inspect on an unknown object runs arbitrary APPLICATION code on
+    # the failure path; truncating the result bounds storage, not cost. The
+    # default is a safe structural summary, with full inspect per type by
+    # opt-in and a wall-clock budget even then.
+    attr_accessor :local_variable_inspect_allowlist   # Class names whose #inspect may run (default: safe built-ins)
+    attr_accessor :local_variable_inspect_budget_ms   # Wall-clock budget for one #inspect (default: 5)
 
     # Instance variable capture from tp.self (receiver object at raise time)
     attr_accessor :enable_instance_variables           # Master switch (default: false)
@@ -302,7 +310,8 @@ module RailsErrorDashboard
 
       @use_separate_database = ENV.fetch("USE_SEPARATE_ERROR_DB", "false") == "true"
 
-      # Retention policy - days to keep errors before automatic deletion (default: 90)
+      # Retention policy - days an error may go unseen (last_seen_at) before it is
+      # deleted automatically (default: 90). An error still occurring is kept.
       # Set to nil to keep errors forever (not recommended for production)
       # Schedule cleanup: RailsErrorDashboard::RetentionCleanupJob.perform_later
       @retention_days = 90
@@ -384,6 +393,8 @@ module RailsErrorDashboard
       @notification_minimum_severity = :low  # Notify on all severities (current behavior)
       @notification_cooldown_minutes = 5     # 5 min cooldown per error_hash (0 = disabled)
       @notification_threshold_alerts = [ 10, 50, 100, 500, 1000 ] # Occurrence milestones
+      @notification_burst_limit = 10          # New-error notifications per window, per process (0 = no cap)
+      @notification_burst_window_seconds = 60 # One summary message replaces the rest of the window
 
       # Breadcrumbs defaults - OFF by default (opt-in)
       @enable_breadcrumbs = false         # Master switch
@@ -410,6 +421,20 @@ module RailsErrorDashboard
       @local_variable_max_array_items = 10      # Max array items to serialize
       @local_variable_max_hash_items = 20       # Max hash entries to serialize
       @local_variable_filter_patterns = []      # Additional sensitive variable name patterns
+      # Struct is serialized MEMBER-WISE (never via its own #inspect), so it
+      # needs no allowlist entry -- see VariableSerializer.serialize_struct.
+      #
+      # ActiveModel is deliberately NOT allowlisted. Reading
+      # ActiveModel::Attributes#attributes runs each attribute's type cast,
+      # which is application code, so neither #inspect nor member-wise reading
+      # can be bounded for it; it gets a safe summary instead.
+      #
+      # Anything added here opts that type IN to unbounded execution: the only
+      # way to interrupt arbitrary Ruby mid-call is Timeout, which is not safe
+      # on the capture path. The budget below selects the stored OUTPUT after
+      # the fact; it does not bound the work.
+      @local_variable_inspect_allowlist = []
+      @local_variable_inspect_budget_ms = 5
 
       # Instance variable capture defaults - OFF by default (opt-in)
       @enable_instance_variables = false         # Capture ivars from tp.self at raise time
@@ -854,6 +879,19 @@ module RailsErrorDashboard
         errors << "notification_threshold_alerts must be an Array (got: #{notification_threshold_alerts.class})"
       end
 
+      # Validate the first-occurrence burst cap (non-negative integers; 0 or nil
+      # turns the cap off)
+      {
+        notification_burst_limit: notification_burst_limit,
+        notification_burst_window_seconds: notification_burst_window_seconds
+      }.each do |name, value|
+        next if value.nil?
+
+        unless value.is_a?(Integer) && value >= 0
+          errors << "#{name} must be a non-negative Integer (got: #{value.inspect})"
+        end
+      end
+
       # Log warnings (non-fatal issues)
       warnings.each do |warning|
         Rails.logger.warn "[Rails Error Dashboard] #{warning}" if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger

data/lib/rails_error_dashboard/engine.rb

@@ -71,6 +71,11 @@ module RailsErrorDashboard
         next
       end
 
+      # Resolve the running commit now (three small file reads, memoised, never
+      # raises) so that no capture ever pays for it. Skipped when the SHA is
+      # configured: then it is never consulted.
+      RailsErrorDashboard.detected_git_sha if RailsErrorDashboard.configuration.git_sha.blank?
+
       if RailsErrorDashboard.configuration.enable_error_subscriber
         Rails.error.subscribe(RailsErrorDashboard::ErrorReporter.new)
       end
@@ -80,6 +85,19 @@ module RailsErrorDashboard
         RailsErrorDashboard::Subscribers::BreadcrumbSubscriber.subscribe!
       end
 
+      # Give background jobs a breadcrumb buffer of their own. init_buffer had
+      # exactly one caller -- the Rack middleware -- so a job never entered the
+      # HTTP stack and had no buffer at all; every subscriber early-returns on
+      # `unless current_buffer`, so a failing job's SQL and custom crumbs were
+      # dropped in the one place an error is hardest to reproduce.
+      #
+      # Registered unconditionally and gated at PERFORM time, not here:
+      # enable_breadcrumbs defaults to false, and the ActiveJob callback list
+      # is fixed once the class loads, so a boot-time gate would leave this
+      # permanently unregistered for any host that turns the feature on in an
+      # initializer that runs later. Off, it costs one config read per job.
+      RailsErrorDashboard::Subscribers::BreadcrumbSubscriber.install_job_buffer!
+
       # Subscribe to Rack Attack AS::Notifications events (requires Rack::Attack).
       # Breadcrumbs are NOT required — events persist to their own table (issue #143).
       if RailsErrorDashboard.configuration.enable_rack_attack_tracking &&
@@ -188,6 +206,16 @@ module RailsErrorDashboard
       # Enable TracePoint(:raise) + TracePoint(:rescue) for swallowed exception detection
       if RailsErrorDashboard.configuration.detect_swallowed_exceptions
         RailsErrorDashboard::Services::SwallowedExceptionTracker.enable!
+
+        # Drain buffered counts at the end of every request and job. Without
+        # this the buffer is only ever drained by a LATER rescue on the SAME
+        # thread, so a swallowed exception that happens once stays invisible
+        # until the process exits. to_complete fires after the response body
+        # is closed, so it never delays a request (safety rule 2); the flush is
+        # deadline-gated, so a flood is still one write per interval.
+        Rails.application.executor.to_complete do
+          RailsErrorDashboard::Services::SwallowedExceptionTracker.flush_if_due!
+        end
       end
 
       # Import crash files from previous process death, then register at_exit hook

data/lib/rails_error_dashboard/manual_error_reporter.rb

@@ -42,7 +42,11 @@ module RailsErrorDashboard
     # @param app_version [String, nil] Version of the app where error occurred
     # @param metadata [Hash, nil] Additional custom metadata about the error
     # @param occurred_at [Time, nil] When the error occurred (defaults to Time.current)
-    # @param severity [Symbol, nil] Severity level (:critical, :high, :medium, :low)
+    # @param severity [Symbol, nil] IGNORED, and kept only so existing callers
+    #   do not break. Severity is not stored: ErrorLog#severity is CLASSIFIED
+    #   from error_type by Services::SeverityClassifier, so the way to control
+    #   it is the error_type you report. Accepting this silently made callers
+    #   believe they had set a value that was never read.
     # @param source [String, nil] Source identifier (e.g., "frontend", "mobile_app")
     #
     # @return [ErrorLog, nil] The created error log record, or nil if filtered/ignored
@@ -65,8 +69,7 @@ module RailsErrorDashboard
     #     user_agent: request.user_agent,
     #     ip_address: request.remote_ip,
     #     app_version: "1.2.3",
-    #     metadata: { card_type: "visa", amount: 99.99 },
-    #     severity: :high
+    #     metadata: { card_type: "visa", amount: 99.99 }
     #   )
     def self.report(
       error_type:,
@@ -100,10 +103,18 @@ module RailsErrorDashboard
         platform: platform,
         app_version: app_version,
         metadata: metadata,
-        occurred_at: occurred_at || Time.current,
-        severity: severity
+        occurred_at: occurred_at || Time.current
       }.compact # Remove nil values
 
+      # severity is deliberately NOT forwarded: nothing downstream reads it,
+      # and passing it on would keep the illusion that it does.
+      if severity.present?
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] ManualErrorReporter: severity: is ignored — " \
+          "severity is classified from error_type (#{error_type})."
+        )
+      end
+
       # Use the existing LogError command
       Commands::LogError.call(synthetic_exception, context)
     end

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -17,7 +17,7 @@ module RailsErrorDashboard
 
       def call
         # Cache analytics data for 5 minutes to reduce database load
-        # Cache key includes days parameter and last error update timestamp
+        # Cache key includes the days parameter and the cache generation
         Rails.cache.fetch(cache_key, expires_in: 5.minutes) do
           {
             days: @days,
@@ -41,13 +41,14 @@ module RailsErrorDashboard
         # - Query class name
         # - Days parameter (different time ranges = different caches)
         # - Application ID (per-app caching)
-        # - Last error update timestamp (auto-invalidates when errors change)
+        # - The cache generation (bumped by user actions; see AnalyticsCacheManager).
+        #   Captures do not bump it: they rely on the 5-minute TTL.
         # - Start date (ensures correct time window)
         [
           "analytics_stats",
           @days,
           @application_id || "all",
-          base_scope.maximum(:updated_at)&.to_i || 0,
+          Services::AnalyticsCacheManager.generation,
           @start_date.to_date.to_s
         ].join("/")
       end
@@ -66,43 +67,62 @@ module RailsErrorDashboard
 
       # 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.
+      # An ErrorLog row is a GROUP; its occurred_at is FIRST-SEEN and is never
+      # rewritten when the error recurs.
+      #
+      #   EVENT figures  -> Queries::EventVolume, which counts occurrence rows
+      #                     + storm buckets + the untracked remainder, each
+      #                     against its OWN timestamp.
+      #   GROUP figures  -> base_query, which selects groups by first-seen.
+      #                     Correct here: a group is the thing that gets
+      #                     resolved, and an event cannot be.
+      #
+      # Mixing them is what made this page disagree with the Overview: filtering
+      # GROUPS by first-seen and then summing their LIFETIME occurrence_count
+      # answers "how much total volume do the groups born in this window carry",
+      # not "how many events happened in this window". A group first seen in
+      # August that recurred today was excluded entirely, so the page reported
+      # zero events while its own affected-users table listed the very event.
       def error_statistics
         {
           total: event_count,
           total_groups: base_query.count,
           unresolved: base_query.unresolved.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),
+          by_type: volume.by_group_attribute(:error_type).sort_by { |_, count| -count }.to_h,
+          by_day: volume.by_day.transform_keys(&:to_s),
           affected_users_incomplete: affected_users_incomplete?
         }
       end
 
-      # Total EVENTS in the window. dashboard_stats.rb and
-      # platform_comparison.rb:165 count the same way.
+      # One EventVolume for the window, reused by every EVENT figure below so
+      # they cannot drift apart from each other or from the headline total.
+      def volume
+        @volume ||= Queries::EventVolume.new(base_scope, @start_date)
+      end
+
+      # Total EVENTS in the window. dashboard_stats.rb counts the same way,
+      # through the same primitive -- that agreement is asserted by
+      # spec/queries/overview_analytics_agreement_spec.rb.
       def event_count
-        base_query.sum(:occurrence_count)
+        volume.count
       end
 
       def errors_over_time
-        base_query.group_by_day(:occurred_at).sum(:occurrence_count)
+        volume.by_day
       end
 
+      # Top 10 by EVENTS. Deliberately a partial breakdown -- it does not sum
+      # to the headline total, and the agreement spec treats it as such.
       def errors_by_type
-        base_query.group(:error_type)
-                  .sum(:occurrence_count)
-                  .sort_by { |_, count| -count }
-                  .first(10)
-                  .to_h
+        volume.by_group_attribute(:error_type)
+              .sort_by { |_, count| -count }
+              .first(10)
+              .to_h
       end
 
       def errors_by_platform
-        base_query.group(:platform).sum(:occurrence_count)
+        volume.by_group_attribute(:platform)
       end
 
       # NULL (captured before the column existed) is reported under :unknown
@@ -110,14 +130,16 @@ module RailsErrorDashboard
       def errors_by_environment
         return {} unless ErrorLog.column_names.include?("environment")
 
-        base_query.group(:environment).sum(:occurrence_count).transform_keys { |env| env.nil? ? :unknown : env }
+        volume.by_group_attribute(:environment).transform_keys { |env| env.nil? ? :unknown : env }
       end
 
+      # Diurnal pattern: which hour of the day errors peak in, 0..23.
+      #
+      # Counted per EVENT against the event's own timestamp. Grouping ErrorLog
+      # by its first-seen hour put a group's whole lifetime volume on the hour
+      # it was first seen, so a recurrence never moved the curve.
       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).sum(:occurrence_count)
+        volume.by_hour_of_day
       end
 
       # Events per user, counted from OCCURRENCE rows.
@@ -149,17 +171,52 @@ module RailsErrorDashboard
 
         # 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 }
+        # belongs in the table. The fallback covers ONLY groups with no
+        # occurrence coverage at all in this window.
+        #
+        # It used to merge by taking the larger of the two counts per user, and
+        # that overstated real users: the group's user_id is overwritten by
+        # every new occurrence, so group_user_counts attributes a group's whole
+        # lifetime count to whoever hit it LAST. For occurrences {A: 2, B: 1}
+        # the group figure for B was 3, max kept 3, and the page reported five
+        # events for a three-event group. A number that overstates a user's
+        # events cannot be presented as an "at least" bound, so the uncovered
+        # case is counted and the covered case is left to the occurrence rows.
+        uncovered = uncovered_group_user_counts
+        counts.merge(uncovered) { |_user, from_occurrences, from_groups| from_occurrences + from_groups }
       rescue StandardError
         group_user_counts
       end
 
+      # GROUP-based on purpose: this is the fallback for groups with no
+      # per-event record, where the group's own user_id and lifetime count are
+      # the only evidence that exists. Routing it through EventVolume would be
+      # wrong -- EventVolume counts events, and this needs the per-user split
+      # that only the group row carries. See design.md D5.
       def group_user_counts
         base_query.where.not(user_id: nil).group(:user_id).sum(:occurrence_count)
       end
 
+      # Groups in this window that have NO occurrence row at all: rows from
+      # before occurrence tracking, and groups whose every event was shed by
+      # storm protection. Their occurrence_count is the only evidence those
+      # events happened, and the group's own user_id the only attribution
+      # available -- a floor, which affected_users_incomplete? reports.
+      #
+      # A group with even one occurrence row is excluded: its per-event rows
+      # are authoritative, and adding the group total on top is what produced
+      # the overcount.
+      def uncovered_group_user_counts
+        covered = ErrorOccurrence.where(error_log_id: base_query.select(:id)).select(:error_log_id)
+
+        base_query.where.not(user_id: nil)
+                  .where.not(id: covered)
+                  .group(:user_id)
+                  .sum(:occurrence_count)
+      rescue StandardError
+        {}
+      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
@@ -214,11 +271,13 @@ module RailsErrorDashboard
       end
 
       def mobile_errors_count
-        base_query.where(platform: [ "iOS", "Android" ]).sum(:occurrence_count)
+        Queries::EventVolume.in_window(base_scope.where(platform: [ "iOS", "Android" ]), @start_date)
       end
 
       def api_errors_count
-        base_query.where("platform IS NULL OR platform = ?", "API").sum(:occurrence_count)
+        Queries::EventVolume.in_window(
+          base_scope.where("platform IS NULL OR platform = ?", "API"), @start_date
+        )
       end
 
       #  Pattern insights for top error types

data/lib/rails_error_dashboard/queries/baseline_stats.rb

@@ -23,6 +23,113 @@ module RailsErrorDashboard
         new(error_type, platform).weekly_baseline
       end
 
+      # Pairs considered by .current_anomalies, busiest first. A bound, so the
+      # check costs the same whether 5 or 50,000 error types are stored.
+      MAX_ANOMALY_PAIRS = 500
+      BASELINE_PRECEDENCE = %w[hourly daily weekly].freeze
+
+      # Every (error_type, platform) pair that is anomalous RIGHT NOW, for all
+      # pairs at once. Same rule as #check_current_anomaly -- the first baseline
+      # available among hourly / daily / weekly, compared against this hour /
+      # today / this week -- but in a fixed number of queries instead of about six
+      # per pair. DashboardStats calls this from the live stats broadcast, which
+      # runs inside the host app's capture path.
+      #
+      # Only pairs with an event this week are looked at: a pair with none has a
+      # count of zero, which no baseline can call anomalous.
+      #
+      # @return [Array<Hash>] error_type, platform, count, level, std_devs_above,
+      #   baseline_type. Empty on any failure -- never raises.
+      def self.current_anomalies(sensitivity: 2, application_id: nil)
+        return [] unless defined?(ErrorBaseline) && ErrorBaseline.table_exists?
+
+        counts = current_counts_by_pair(application_id: application_id)
+        return [] if counts.empty?
+
+        baselines = latest_baselines_for(counts.keys)
+
+        counts.filter_map do |(error_type, platform), windows|
+          kind = BASELINE_PRECEDENCE.find { |type| baselines[[ error_type, platform, type ]] }
+          next unless kind
+
+          baseline = baselines[[ error_type, platform, kind ]]
+          # A flat history has no spread to measure against; dividing by it
+          # makes any count above the mean infinitely anomalous.
+          next if baseline.std_dev.nil? || baseline.std_dev.zero?
+
+          count = windows.fetch(kind.to_sym)
+          level = baseline.anomaly_level(count, sensitivity: sensitivity)
+          next unless level
+
+          {
+            error_type: error_type,
+            platform: platform,
+            count: count,
+            level: level,
+            std_devs_above: baseline.std_devs_above_mean(count),
+            baseline_type: kind
+          }
+        end
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] current_anomalies failed: #{e.class}: #{e.message}")
+        []
+      end
+
+      # { [error_type, platform] => { hourly:, daily:, weekly: } } in ONE grouped
+      # query, counted in the units the baselines were built from (occurrence
+      # rows when that table exists). The week is the widest window, so it is
+      # the WHERE; the day and the hour are conditional sums inside it.
+      def self.current_counts_by_pair(application_id: nil)
+        logs = ErrorLog.table_name
+        column = Services::BaselineCalculator.time_column
+        now = Time.current
+
+        relation = if defined?(ErrorOccurrence) && ErrorOccurrence.table_exists?
+          ErrorOccurrence.joins(:error_log)
+        else
+          ErrorLog.all
+        end
+        relation = relation.where(logs => { application_id: application_id }) if application_id.present?
+
+        since = ->(time) { ErrorLog.sanitize_sql_array([ "SUM(CASE WHEN #{column} >= ? THEN 1 ELSE 0 END)", time ]) }
+
+        rows = relation
+                 .where("#{column} >= ?", now.beginning_of_week)
+                 .group("#{logs}.error_type", "#{logs}.platform")
+                 .order(Arel.sql("COUNT(*) DESC"))
+                 .limit(MAX_ANOMALY_PAIRS)
+                 .pluck(Arel.sql("#{logs}.error_type"), Arel.sql("#{logs}.platform"), Arel.sql("COUNT(*)"),
+                        Arel.sql(since.call(now.beginning_of_day)), Arel.sql(since.call(now.beginning_of_hour)))
+
+        rows.to_h do |error_type, platform, weekly, daily, hourly|
+          [ [ error_type, platform ], { weekly: weekly.to_i, daily: daily.to_i, hourly: hourly.to_i } ]
+        end
+      end
+
+      # { [error_type, platform, baseline_type] => ErrorBaseline }, the most recent
+      # row of each, in ONE query. Baseline rows accumulate (one per calculation
+      # period), so "latest" is resolved in SQL with a join on MAX(period_start)
+      # rather than by loading the history. The join form is portable to every
+      # adapter; a row-value IN is not.
+      def self.latest_baselines_for(pairs)
+        table = ErrorBaseline.table_name
+        types = pairs.map(&:first).compact.uniq
+        return {} if types.empty?
+
+        latest = ErrorBaseline.where(error_type: types, baseline_type: BASELINE_PRECEDENCE)
+                              .group(:error_type, :platform, :baseline_type)
+                              .select(:error_type, :platform, :baseline_type, "MAX(period_start) AS latest_period_start")
+
+        ErrorBaseline
+          .joins("INNER JOIN (#{latest.to_sql}) latest_baselines ON " \
+                 "latest_baselines.error_type = #{table}.error_type AND " \
+                 "latest_baselines.platform = #{table}.platform AND " \
+                 "latest_baselines.baseline_type = #{table}.baseline_type AND " \
+                 "latest_baselines.latest_period_start = #{table}.period_start")
+          .index_by { |baseline| [ baseline.error_type, baseline.platform, baseline.baseline_type ] }
+      end
+      private_class_method :current_counts_by_pair, :latest_baselines_for
+
       def initialize(error_type, platform)
         @error_type = error_type
         @platform = platform