rails_error_dashboard 0.11.5 → 0.11.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b521e9d43ec3c1c324d5e8c79fc1d9547e76996863e49cad98220783cbdf38af
-  data.tar.gz: 03c5cb566af62a40a0b2509ace0a364d859e49ee0afffee6a1fc96bf19287866
+  metadata.gz: 31b48d634cb3ef3737bfc4744993cd315deec8555bc6a0a7da55d6a3e3b011d5
+  data.tar.gz: 32fbeecb52dcbb0b48bf3f10f9fcc6da854ac20e0f1236a8fe0d37d1a3288475
 SHA512:
-  metadata.gz: 37afb3d4f509764cf654ae1c93babde6d3045eccd9c8c51c7513adf7416b08d6a012ab35f84de2883f2ffdf30bd0f6ae77d5d6a8a4d8fd56f11db91fc6b1b3a7
-  data.tar.gz: 126d8dd6c85f7836d731c96c06b27db915e1fc079b7b713d4aace4216de7460432c1a57dfdc20571e544281ccbcc55f32f03ebf338b70614e3ed7e870856835c
+  metadata.gz: 76346c5b3c5b5ba64e272d27024dc29a4635eca2024458a10b1eff9b0a842dd5cb96bbd671566d59ce3b53f44d5ca7d61250f4f620f6b4e0e4212f09d2c884d4
+  data.tar.gz: e9fcc3afb33b3d550c830453e1d8e1325081e6f182103975855dc337c56ea1735fbfccc3879b8af35cb1fdb119eb925ccff5b516108a2eb9d3eb300ff5094e8f

data/README.md

@@ -184,7 +184,7 @@ config.enable_breadcrumbs = true
 
 Know your app's runtime state at the moment of failure — GC stats, process memory, thread count, connection pool utilization, Puma thread stats, RubyVM cache health, YJIT compilation stats, and deep runtime insights captured automatically.
 
-- Sub-millisecond total snapshot, every metric individually rescue-wrapped
+- Sub-millisecond for the in-process metrics, every metric individually rescue-wrapped. The one exception is job-queue depth (five `COUNT`s for Solid Queue, a Redis round-trip for Sidekiq): those are queries against your queue store, cached for 10 s per process and switchable off with `config.system_health_queue_stats = false`
 - No ObjectSpace scanning, no Thread backtraces, no subprocess calls
 - RubyVM.stat: constant cache invalidations, shape cache stats
 - YJIT runtime stats: compiled iseqs, invalidation count, code region sizes
@@ -476,9 +476,10 @@ Seven analysis engines built in:
 <details>
 <summary><strong>Local Variable + Instance Variable Capture</strong></summary>
 
-See the exact values of local variables and instance variables at the moment an exception was raised — the most valuable debugging context possible.
+See the values of local variables and instance variables at the moment an exception was raised — the most valuable debugging context possible.
 
 - TracePoint(`:raise`) captures locals and ivars before the stack unwinds
+- Strings, arrays and hashes are snapshotted at raise time (one level deep, bounded by the limits below), so an `ensure` block that cleans up state does not overwrite what you see. Other objects are kept by reference and show their state at serialization time
 - Configurable limits: max variable count, nesting depth, string truncation length
 - Sensitive data auto-filtered via Rails `filter_parameters` — passwords, tokens, and PII never stored
 - Never stores Binding objects — values extracted immediately, Binding is GC'd

data/app/jobs/rails_error_dashboard/async_error_logging_job.rb

@@ -37,8 +37,16 @@ module RailsErrorDashboard
     # Reconstruct exception from serialized data
     # @param data [Hash] Serialized exception data
     # @return [Exception] Reconstructed exception object
+    #
+    # Never relies on the subclass constructor: many real exception classes
+    # take something other than a message (ActiveRecord::RecordInvalid wants
+    # the record, custom errors take keywords), and `Klass.new(message)` on
+    # those raised inside the job, which rescued it and dropped the capture.
+    # Allocate the right class so error_type/fingerprint stay correct, then
+    # set the message with Exception's own initializer, bypassing whatever
+    # the subclass expects. Fall back to the constructor for classes whose
+    # `message` needs state their initializer sets.
     def reconstruct_exception(data)
-      # Get or create the exception class
       exception_class = begin
         data[:class_name].constantize
       rescue NameError
@@ -46,13 +54,33 @@ module RailsErrorDashboard
         StandardError
       end
 
-      # Create new exception with the original message
-      exception = exception_class.new(data[:message])
+      exception = allocate_exception(exception_class, data[:message]) ||
+                  construct_exception(exception_class, data[:message]) ||
+                  StandardError.new(data[:message])
 
       # Restore the backtrace
       exception.set_backtrace(data[:backtrace]) if data[:backtrace]
 
       exception
     end
+
+    def allocate_exception(exception_class, message)
+      return nil unless exception_class < Exception
+
+      exception = exception_class.allocate
+      Exception.instance_method(:initialize).bind_call(exception, message)
+      exception.message # a subclass `message` that needs constructor state raises here
+      exception
+    rescue StandardError, NoMemoryError
+      nil
+    end
+
+    def construct_exception(exception_class, message)
+      exception = exception_class.new(message)
+      exception.message
+      exception
+    rescue StandardError
+      nil
+    end
   end
 end

data/app/jobs/rails_error_dashboard/baseline_calculation_job.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Recalculates every error-type/platform baseline from recent history.
+  #
+  # Nothing in the gem schedules this: run it from the host's scheduler
+  # (Solid Queue recurring tasks, sidekiq-cron, whenever, cron + runner)
+  # roughly daily. Without it there are no baselines and no baseline alerts.
+  class BaselineCalculationJob < ApplicationJob
+    queue_as :default
+
+    def perform
+      result = Services::BaselineCalculator.calculate_all_baselines
+      Rails.logger.info("[RailsErrorDashboard] Baselines recalculated: #{result[:calculated]}")
+      result
+    rescue => e
+      Rails.logger.error("[RailsErrorDashboard] BaselineCalculationJob failed: #{e.class}: #{e.message}")
+      raise
+    end
+  end
+end

data/app/models/rails_error_dashboard/error_log.rb

@@ -339,13 +339,10 @@ module RailsErrorDashboard
       return { anomaly: false, message: "Feature disabled" } unless RailsErrorDashboard.configuration.enable_baseline_alerts
       return { anomaly: false, message: "No baseline available" } unless defined?(Queries::BaselineStats)
 
-      # Get count of this error type today
-      today_count = ErrorLog.where(
-        error_type: error_type,
-        platform: platform
-      ).where("occurred_at >= ?", Time.current.beginning_of_day).count
-
-      Queries::BaselineStats.new(error_type, platform).check_anomaly(today_count, sensitivity: sensitivity)
+      # Current hour / day / week counted in the baselines' own units — a
+      # day's count against an hourly baseline flagged everything.
+      Queries::BaselineStats.new(error_type, platform)
+                            .check_current_anomaly(sensitivity: sensitivity, application_id: application_id)
     end
 
     # Detect cyclical occurrence patterns (daily/weekly rhythms)

data/app/models/rails_error_dashboard/error_logs_record.rb

@@ -34,5 +34,39 @@ module RailsErrorDashboard
     # Database connection will be configured by the engine initializer
     # after the user's configuration is loaded
     # See lib/rails_error_dashboard/engine.rb
+
+    # Rails' default for a string column when the adapter has one (MySQL).
+    DEFAULT_STRING_LIMIT = 255
+
+    # Truncate string-typed attributes to their column limits. MySQL in strict
+    # mode rejects an over-long value outright, the capture path rescues the
+    # failure, and the error is silently lost — over a 300-character app
+    # version. Columns without a declared limit are clamped to the Rails
+    # default so behaviour is the same on every adapter. Text columns are
+    # untouched. Identity (error_hash) is computed from the raw values before
+    # this runs, so clamping display metadata never changes grouping.
+    # @param attributes [Hash] attribute name => value
+    # @return [Hash] a copy with over-long strings truncated
+    def self.clamp_string_attributes(attributes)
+      limits = string_column_limits
+      attributes.each_with_object({}) do |(name, value), clamped|
+        limit = limits[name.to_s]
+        clamped[name] = if limit && value.is_a?(String) && value.length > limit
+          value[0, limit]
+        else
+          value
+        end
+      end
+    rescue => e
+      RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] clamp_string_attributes failed: #{e.message}")
+      attributes
+    end
+
+    # @return [Hash] column name => character limit, string columns only (memoized per class)
+    def self.string_column_limits
+      @string_column_limits ||= columns_hash.each_with_object({}) do |(name, column), limits|
+        limits[name] = column.limit || DEFAULT_STRING_LIMIT if column.type == :string
+      end
+    end
   end
 end

data/db/migrate/20260908000001_add_release_to_error_occurrences.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Release attribution belongs on the occurrence, not the group.
+#
+# An ErrorLog row is a GROUP: it keeps the app_version/git_sha of the first
+# capture in its window and recurrences do not touch them. So an error first
+# seen in v1 that kept firing after the v2 deploy was reported entirely under
+# v1, and the release timeline could not answer "did this deploy make things
+# worse". Each ErrorOccurrence now records the release it happened under, and
+# ReleaseTimeline counts occurrences per release.
+#
+# Existing occurrences are backfilled from their group's release. That is the
+# same attribution the dashboard showed before this migration (no worse), and
+# it keeps historical releases populated instead of dropping to zero.
+class AddReleaseToErrorOccurrences < ActiveRecord::Migration[7.0]
+  def up
+    return if column_exists?(:rails_error_dashboard_error_occurrences, :app_version)
+
+    add_column :rails_error_dashboard_error_occurrences, :app_version, :string
+    add_column :rails_error_dashboard_error_occurrences, :git_sha, :string
+    add_index :rails_error_dashboard_error_occurrences, [ :app_version, :occurred_at ],
+              name: "index_error_occurrences_on_version_and_time"
+
+    # Correlated subqueries rather than UPDATE ... FROM / JOIN: the one form
+    # SQLite, PostgreSQL and MySQL all accept.
+    execute <<~SQL.squish
+      UPDATE rails_error_dashboard_error_occurrences
+      SET app_version = (
+            SELECT app_version FROM rails_error_dashboard_error_logs
+            WHERE rails_error_dashboard_error_logs.id = rails_error_dashboard_error_occurrences.error_log_id
+          ),
+          git_sha = (
+            SELECT git_sha FROM rails_error_dashboard_error_logs
+            WHERE rails_error_dashboard_error_logs.id = rails_error_dashboard_error_occurrences.error_log_id
+          )
+      WHERE app_version IS NULL
+    SQL
+  end
+
+  def down
+    remove_index :rails_error_dashboard_error_occurrences, name: "index_error_occurrences_on_version_and_time"
+    remove_column :rails_error_dashboard_error_occurrences, :git_sha
+    remove_column :rails_error_dashboard_error_occurrences, :app_version
+  end
+end

data/lib/rails_error_dashboard/commands/find_or_increment_error.rb

@@ -4,6 +4,10 @@ module RailsErrorDashboard
   module Commands
     # Command: Find an existing error by hash or create a new one
     # Uses pessimistic locking to prevent race conditions in multi-app scenarios.
+    # The whole find-and-write runs inside ONE transaction: a row lock taken
+    # by SELECT ... FOR UPDATE lives only as long as the transaction that took
+    # it, so a lock on a standalone SELECT was released before the UPDATE ran
+    # and two concurrent captures could both read count N and both write N+1.
     #
     # Search order:
     # 1. Unresolved errors with same hash within 24 hours → increment occurrence count
@@ -37,16 +41,18 @@ module RailsErrorDashboard
       end
 
       def call
-        # Priority 1: Find unresolved match (existing behavior)
-        existing = find_unresolved
-        return increment_existing(existing) if existing
+        ErrorLog.transaction do
+          # Priority 1: Find unresolved match (existing behavior)
+          existing = find_unresolved
+          next increment_existing(existing) if existing
 
-        # Priority 2: Find resolved/wont_fix match → reopen
-        resolved = find_resolved
-        return reopen_existing(resolved) if resolved
+          # Priority 2: Find resolved/wont_fix match → reopen
+          resolved = find_resolved
+          next reopen_existing(resolved) if resolved
 
-        # Priority 3: Create new record
-        create_new_or_retry
+          # Priority 3: Create new record
+          create_new_or_retry
+        end
       end
 
       private
@@ -132,7 +138,12 @@ module RailsErrorDashboard
       end
 
       def create_new_or_retry
-        ErrorLog.create!(@attributes.reverse_merge(resolved: false))
+        # Savepoint: on PostgreSQL a unique-violation poisons the enclosing
+        # transaction, and the retry lookups below would fail with "current
+        # transaction is aborted" instead of finding the winner's row.
+        ErrorLog.transaction(requires_new: true) do
+          ErrorLog.create!(@attributes.reverse_merge(resolved: false))
+        end
       rescue ActiveRecord::RecordNotUnique
         # Race condition: another process created the same error
         retry_existing = with_environment(

data/lib/rails_error_dashboard/commands/flush_storm_counts.rb

@@ -8,7 +8,8 @@ module RailsErrorDashboard
     # Runs in a background job (DB allowed). For each counted fingerprint:
     #   1. Recompute the canonical error_hash from the stored identity parts
     #      (the gate's key deliberately omits application_id — resolved here)
-    #   2. Unresolved match  → single UPDATE: occurrence_count += N
+    #   2. Unresolved match  → the ONE row FindOrIncrementError would pick
+    #      (24 h window, exact environment first): occurrence_count += N
     #   3. Resolved match    → reopen (mirrors FindOrIncrementError semantics)
     #   4. No match          → create a minimal ErrorLog from the exemplar
     #
@@ -59,26 +60,33 @@ module RailsErrorDashboard
 
         error_hash = canonical_hash(entry, application)
         last_seen = parse_time(entry["last_seen_at"]) || Time.current
-        env = current_environment
-
-        # Priority 1: unresolved match — one UPDATE, no row instantiation.
-        # Environment mirrors FindOrIncrementError: exact row first, then a
-        # legacy NULL row which is stamped as it is claimed. Two statements
-        # rather than one IN (env, NULL), because update_all would hit BOTH
-        # rows when they coexist and double-count.
-        unresolved = ErrorLog.unresolved.where(error_hash: error_hash, application_id: application.id)
-        if env
-          updated = unresolved.where(environment: env)
-            .update_all([ "occurrence_count = occurrence_count + ?, last_seen_at = ?", count, last_seen ])
-          return count if updated.positive?
-
-          updated = unresolved.where(environment: nil)
-            .update_all([ "occurrence_count = occurrence_count + ?, last_seen_at = ?, environment = ?",
-                          count, last_seen, env ])
-          return count if updated.positive?
-        else
-          updated = unresolved.update_all([ "occurrence_count = occurrence_count + ?, last_seen_at = ?", count, last_seen ])
-          return count if updated.positive?
+        # An explicit environment captured at the gate wins over the worker's
+        # own, mirroring LogError#resolve_environment for full captures.
+        env = current_environment && (entry["environment"].presence || current_environment)
+
+        # Priority 1: unresolved match — ONE row, chosen exactly as
+        # FindOrIncrementError chooses it (same hash + application, occurred
+        # within 24 h, exact environment before a legacy NULL row, most
+        # recently seen first), then a single atomic UPDATE on that id.
+        #
+        # It must be one row: the normal path opens a fresh group once the
+        # previous one's occurred_at falls outside the 24 h window, so a
+        # long-running unresolved error legitimately owns several unresolved
+        # rows. An update_all across the whole hash would add N to every one
+        # of them — seven real events becoming twelve counted occurrences.
+        target = unresolved_target(error_hash, application, env)
+        if target
+          if env && target.environment.blank?
+            ErrorLog.where(id: target.id).update_all([
+              "occurrence_count = occurrence_count + ?, last_seen_at = ?, environment = ?",
+              count, last_seen, env
+            ])
+          else
+            ErrorLog.where(id: target.id).update_all([
+              "occurrence_count = occurrence_count + ?, last_seen_at = ?", count, last_seen
+            ])
+          end
+          return count
         end
 
         # Priority 2: resolved/wont_fix match — reopen, mirroring
@@ -107,12 +115,17 @@ module RailsErrorDashboard
 
         # Priority 3: first seen during count-only mode — minimal ErrorLog
         # from the exemplar (no backtrace/context was captured; the next
-        # occurrence after the storm fills in detail via the normal path)
+        # occurrence after the storm fills in detail via the normal path).
+        #
+        # The exemplar message is RAW — the gate stores what the exception
+        # said so the canonical hash (computed above, from the raw message,
+        # exactly as the full path does) still lands on the same row. It must
+        # therefore go through the same redaction as LogError before it is
+        # persisted; storm protection and sensitive filtering are both on by
+        # default, and an incident is exactly when a password in a message
+        # must not reach the database.
         create_attrs = {
-          environment: env
-        }.compact
-        ErrorLog.create!(
-          **create_attrs,
+          environment: env,
           application_id: application.id,
           error_type: entry["error_class"],
           message: entry["message"],
@@ -124,10 +137,32 @@ module RailsErrorDashboard
           occurrence_count: count,
           error_hash: error_hash,
           resolved: false
-        )
+        }.compact
+        ErrorLog.create!(**ErrorLog.clamp_string_attributes(Services::SensitiveDataFilter.filter_attributes(create_attrs)))
         count
       end
 
+
+      # The unresolved row the full capture path would increment right now.
+      def unresolved_target(error_hash, application, env)
+        scope = ErrorLog.unresolved
+          .where(error_hash: error_hash, application_id: application.id)
+          .where("occurred_at >= ?", 24.hours.ago)
+        if env
+          scope = scope.where(environment: [ env, nil ])
+            .order(Arel.sql("CASE WHEN environment IS NULL THEN 1 ELSE 0 END"))
+        end
+        scope.order(last_seen_at: :desc).select(:id, :environment).first
+      end
+
+      # The redaction LogError applies to a message, for exemplars that reach
+      # the database by any other route (first-seen rows, the storm ledger).
+      def redact_message(message)
+        return message if message.blank?
+
+        Services::SensitiveDataFilter.filter_attributes({ message: message.to_s })[:message]
+      end
+
       # Mirrors ErrorHashGenerator.call exactly: same fields, same order,
       # same normalization — so counts land on the same ErrorLog the full
       # capture path would have used.
@@ -196,7 +231,7 @@ module RailsErrorDashboard
         existing = event.top_fingerprints_list
         fresh = @entries.map { |e|
           e = e.with_indifferent_access if e.respond_to?(:with_indifferent_access)
-          { "class" => e["error_class"], "message" => e["message"].to_s[0, 120], "count" => e["count"].to_i }
+          { "class" => e["error_class"], "message" => redact_message(e["message"]).to_s[0, 120], "count" => e["count"].to_i }
         }
 
         merged = (existing + fresh)

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -299,6 +299,9 @@ module RailsErrorDashboard
         # Apply sensitive data filtering (on by default)
         attributes = Services::SensitiveDataFilter.filter_attributes(attributes)
 
+        # Fit string metadata to its columns (after hashing, before writing)
+        attributes = ErrorLog.clamp_string_attributes(attributes)
+
         # Harvest breadcrumbs (if enabled and column exists)
         if !storm_lite && ErrorLog.column_names.include?("breadcrumbs") && RailsErrorDashboard.configuration.enable_breadcrumbs
           # Sync path: harvest from current thread
@@ -377,13 +380,19 @@ module RailsErrorDashboard
         #  Track individual error occurrence for co-occurrence analysis (if table exists)
         if defined?(ErrorOccurrence) && ErrorOccurrence.table_exists?
           begin
-            ErrorOccurrence.create(
+            occurrence_attrs = {
               error_log: error_log,
               occurred_at: attributes[:occurred_at],
               user_id: attributes[:user_id],
               request_id: error_context.request_id,
               session_id: error_context.session_id
-            )
+            }
+            # The release THIS event happened under. The group keeps its first
+            # release; per-release counts come from here (ReleaseTimeline).
+            occurrence_columns = ErrorOccurrence.column_names
+            occurrence_attrs[:app_version] = attributes[:app_version] if occurrence_columns.include?("app_version")
+            occurrence_attrs[:git_sha] = attributes[:git_sha] if occurrence_columns.include?("git_sha")
+            ErrorOccurrence.create(ErrorOccurrence.clamp_string_attributes(occurrence_attrs))
           rescue => e
             RailsErrorDashboard::Logger.error("Failed to create error occurrence: #{e.message}")
           end

data/lib/rails_error_dashboard/configuration.rb

@@ -169,6 +169,8 @@ module RailsErrorDashboard
 
     # System health snapshot (GC, memory, threads, connection pool at error time)
     attr_accessor :enable_system_health            # Master switch (default: false)
+    attr_accessor :system_health_queue_stats       # Include job-queue depth counts (default: true)
+    attr_accessor :system_health_queue_stats_cache_seconds # Reuse queue counts this long per process (default: 10)
 
     # Local variable capture via TracePoint(:raise)
     attr_accessor :enable_local_variables            # Master switch (default: false)
@@ -393,6 +395,11 @@ module RailsErrorDashboard
 
       # System health snapshot defaults - OFF by default (opt-in)
       @enable_system_health = false  # Capture GC, memory, threads, connection pool at error time
+      # Queue-depth counts are queries against the queue store (five COUNTs
+      # for Solid Queue), the one part of the snapshot that is not sub-ms.
+      # Cached per process so an error burst runs them once per interval.
+      @system_health_queue_stats = true
+      @system_health_queue_stats_cache_seconds = 10
 
       # Local variable capture defaults - OFF by default (opt-in)
       @enable_local_variables = false           # TracePoint(:raise) for local var capture

data/lib/rails_error_dashboard/queries/analytics_stats.rb

@@ -126,7 +126,10 @@ module RailsErrorDashboard
         total = error_statistics[:total]
         return 0 if total.zero?
 
-        resolved_count = ErrorLog.resolved.where("occurred_at >= ?", @start_date).count
+        # 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)
       end
 

data/lib/rails_error_dashboard/queries/baseline_stats.rb

@@ -85,23 +85,58 @@ module RailsErrorDashboard
       # @param current_count [Integer] Current error count
       # @param sensitivity [Integer] Standard deviations threshold (default: 2)
       # @return [Hash] { anomaly: true/false, level: Symbol, baseline_type: String }
-      def check_anomaly(current_count, sensitivity: 2)
-        baseline = hourly_baseline || daily_baseline || weekly_baseline
+      # Compare a count against the first available baseline, in matching
+      # units: the current HOUR's count against the hourly baseline, TODAY's
+      # against the daily, THIS WEEK's against the weekly. A bare positional
+      # count is compared against whichever baseline is found (legacy callers).
+      #
+      # @param current_count [Integer, nil] legacy: one count used for any baseline
+      # @param hourly [Integer, nil] events so far this hour
+      # @param daily [Integer, nil] events so far today
+      # @param weekly [Integer, nil] events so far this week
+      def check_anomaly(current_count = nil, sensitivity: 2, hourly: nil, daily: nil, weekly: nil)
+        candidates = [
+          [ hourly_baseline, hourly || current_count ],
+          [ daily_baseline, daily || current_count ],
+          [ weekly_baseline, weekly || current_count ]
+        ]
+        baseline, count = candidates.find { |b, c| b && c }
 
         if baseline.nil?
           return { anomaly: false, level: nil, baseline_type: nil, message: "No baseline available" }
         end
 
-        level = baseline.anomaly_level(current_count, sensitivity: sensitivity)
+        level = baseline.anomaly_level(count, sensitivity: sensitivity)
 
         {
           anomaly: level.present?,
           level: level,
           baseline_type: baseline.baseline_type,
+          current_count: count,
           threshold: baseline.threshold(sensitivity: sensitivity),
-          std_devs_above: baseline.std_devs_above_mean(current_count)
+          std_devs_above: baseline.std_devs_above_mean(count)
         }
       end
+
+      # Events so far in the current hour / day / week, counted in the same
+      # units the baselines were built from (Services::BaselineCalculator).
+      # @return [Hash] { hourly: Integer, daily: Integer, weekly: Integer }
+      def current_counts(application_id: nil)
+        relation = Services::BaselineCalculator.counting_relation(@error_type, @platform, application_id: application_id)
+        column = Services::BaselineCalculator.time_column
+        now = Time.current
+        {
+          hourly: relation.where("#{column} >= ?", now.beginning_of_hour).count,
+          daily: relation.where("#{column} >= ?", now.beginning_of_day).count,
+          weekly: relation.where("#{column} >= ?", now.beginning_of_week).count
+        }
+      end
+
+      # The anomaly check for right now: current counts against their baselines.
+      # @param application_id [Integer, nil] scope the current counts to one application
+      def check_current_anomaly(sensitivity: 2, application_id: nil)
+        check_anomaly(sensitivity: sensitivity, **current_counts(application_id: application_id))
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -181,14 +181,8 @@ module RailsErrorDashboard
 
         # Check most common error types for anomalies
         base_scope.distinct.pluck(:error_type, :platform).compact.any? do |(error_type, platform)|
-          stats = Queries::BaselineStats.new(error_type, platform)
-          error_count = base_scope.where(
-            error_type: error_type,
-            platform: platform
-          ).where("occurred_at >= ?", Time.current.beginning_of_day).count
-
-          result = stats.check_anomaly(error_count, sensitivity: 2)
-          result[:anomaly]
+          Queries::BaselineStats.new(error_type, platform)
+                                .check_current_anomaly(sensitivity: 2, application_id: @application_id)[:anomaly]
         end
       end
 
@@ -198,19 +192,14 @@ module RailsErrorDashboard
 
         # Find the most anomalous error type
         anomalies = base_scope.distinct.pluck(:error_type, :platform).compact.map do |(error_type, platform)|
-          stats = Queries::BaselineStats.new(error_type, platform)
-          error_count = base_scope.where(
-            error_type: error_type,
-            platform: platform
-          ).where("occurred_at >= ?", Time.current.beginning_of_day).count
-
-          result = stats.check_anomaly(error_count, sensitivity: 2)
+          result = Queries::BaselineStats.new(error_type, platform)
+                                         .check_current_anomaly(sensitivity: 2, application_id: @application_id)
           next unless result[:anomaly]
 
           {
             error_type: error_type,
             platform: platform,
-            count: error_count,
+            count: result[:current_count],
             level: result[:level],
             std_devs_above: result[:std_devs_above]
           }