rails_pulse 0.4.2 → 0.5.0.pre.2

data/app/models/rails_pulse/dashboard/charts/throughput_and_errors.rb

@@ -2,13 +2,12 @@ module RailsPulse
   module Dashboard
     module Charts
       class ThroughputAndErrors
-        def initialize(disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
+        def initialize(disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", window: nil)
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
-          @start_time = start_time
-          @end_time = end_time
+          @window = window
         end
 
         def to_chart_data
@@ -125,10 +124,10 @@ module RailsPulse
 
         private
 
-        # nil unless both start_time and end_time were given, so the default
+        # nil unless a window was given, so the default
         # "recent" view keeps using the trailing-@period-days fallback below.
         def time_window
-          @time_window ||= RailsPulse::TimeWindow.build(@start_time, @end_time)
+          @window
         end
 
         def default_hour_range

data/app/models/rails_pulse/dashboard/concerns/attention_classification.rb

@@ -0,0 +1,104 @@
+module RailsPulse
+  module Dashboard
+    module Concerns
+      # How a route, query or job earns a place in a needs-attention list,
+      # shared by the dashboard panel (NeedsAttention, over the selected
+      # window) and the API's PeriodInsights (over one summary period) so the
+      # two never disagree about what is critical.
+      #
+      # Each classify method returns nil for something healthy, otherwise
+      # [severity, reason, metric, metric_sub, sort_score]. The includer sets
+      # @route_thresholds, @query_thresholds and @job_thresholds.
+      module AttentionClassification
+        include ThresholdConstants
+
+        private
+
+        # `span` finishes the error-rate reason: "this week", "this period".
+        def classify_route(p95, total, errors, error_rate, span)
+          if p95 >= @route_thresholds[:critical] || error_rate >= CRITICAL_ERROR_RATE
+            if error_rate >= CRITICAL_ERROR_RATE
+              [ :critical,
+                "#{error_rate}% error rate · #{total} requests #{span}",
+                "#{errors} errors",
+                "P95 #{p95.round(0).to_i}ms",
+                errors * total.to_f ]
+            else
+              [ :critical,
+                "#{p95.round(0).to_i}ms P95 · exceeds #{@route_thresholds[:critical]}ms threshold",
+                "#{p95.round(0).to_i}ms P95",
+                "#{total} requests",
+                p95 ]
+            end
+          elsif p95 >= @route_thresholds[:slow] || error_rate >= WARNING_ERROR_RATE
+            if error_rate >= WARNING_ERROR_RATE && p95 < @route_thresholds[:slow]
+              [ :warning,
+                "#{error_rate}% error rate · #{total} requests #{span}",
+                "#{errors} errors",
+                "P95 #{p95.round(0).to_i}ms",
+                errors * total.to_f ]
+            else
+              [ :warning,
+                "#{p95.round(0).to_i}ms P95 · #{error_rate > 0 ? "#{error_rate}% error rate" : "above slow threshold"}",
+                "#{p95.round(0).to_i}ms P95",
+                "#{total} requests",
+                p95 ]
+            end
+          end
+        end
+
+        def classify_query(p95, count)
+          if p95 >= @query_thresholds[:critical]
+            severity = :critical
+            reason   = "#{p95.round(0).to_i}ms P95 · exceeds #{@query_thresholds[:critical]}ms threshold"
+          elsif p95 >= @query_thresholds[:slow]
+            severity = :warning
+            reason   = "#{p95.round(0).to_i}ms P95 · above #{@query_thresholds[:slow]}ms slow threshold"
+          else
+            return
+          end
+
+          [ severity, reason, "#{p95.round(0).to_i}ms P95", "#{count} execution#{count == 1 ? "" : "s"}", p95 ]
+        end
+
+        def classify_job(failure_rate, p95, runs, failures, queue)
+          if failure_rate >= CRITICAL_JOB_FAILURE_RATE || p95 >= @job_thresholds[:critical]
+            if failure_rate >= CRITICAL_JOB_FAILURE_RATE
+              [ :critical,
+                "#{queue} queue · #{failure_rate}% failure rate",
+                "#{failures} / #{runs} failed",
+                "P95 #{p95.round(0).to_i}ms",
+                failures * runs.to_f ]
+            else
+              [ :critical,
+                "P95 #{p95.round(0).to_i}ms · exceeds #{@job_thresholds[:critical]}ms threshold",
+                "#{p95.round(0).to_i}ms P95",
+                "#{runs} runs",
+                p95 ]
+            end
+          elsif failure_rate >= WARNING_JOB_FAILURE_RATE || p95 >= @job_thresholds[:slow]
+            if failure_rate >= WARNING_JOB_FAILURE_RATE
+              [ :warning,
+                "#{queue} queue · #{failure_rate}% failure rate",
+                "#{failures} / #{runs} failed",
+                "P95 #{p95.round(0).to_i}ms",
+                failures * runs.to_f ]
+            else
+              [ :warning,
+                "P95 #{p95.round(0).to_i}ms · above slow threshold",
+                "#{p95.round(0).to_i}ms P95",
+                "#{runs} runs",
+                p95 ]
+            end
+          end
+        end
+
+        def truncate_sql(sql)
+          return "" if sql.blank?
+          cleaned = sql.gsub(/\s+/, " ").strip
+          cleaned.length > 80 ? "#{cleaned[0..79]}..." : cleaned
+        end
+      end
+    end
+  end
+end

data/app/models/rails_pulse/dashboard/concerns/time_range_helper.rb

@@ -5,11 +5,34 @@ module RailsPulse
         private
 
         def period_range
-          window = RailsPulse::TimeWindow.build(@start_time, @end_time)
-          return [ window.start_time, window.end_time ] if window
+          return [ @window.start_time, @window.end_time ] if @window
 
           [ @period.days.ago.beginning_of_day, Time.current ]
         end
+
+        # Summary rows that cover the period exactly once. The same traffic is
+        # summarized per hour, day, week and month, so summing across period
+        # types would count it once per granularity. A window of 25 hours or
+        # less reads hourly rows. A longer one reads daily rows up to the start
+        # of today, or to its own end if that comes first, and hourly rows
+        # after today's start, because a day is summarized only once it has
+        # ended.
+        def period_summaries
+          start, finish = period_range
+          return RailsPulse::Summary.where(period_type: "hour", period_start: start..finish) if hourly_period?(start, finish)
+
+          today = Time.zone.now.beginning_of_day
+          RailsPulse::Summary.where(period_type: "day", period_start: start...[ today, finish ].min)
+            .or(RailsPulse::Summary.where(period_type: "hour", period_start: today..finish))
+        end
+
+        # The dashboard passes the period type TimeRange resolved, so these
+        # panels read the same granularity as the cards and charts beside them.
+        def hourly_period?(start, finish)
+          return @period_type == "hour" if @period_type
+
+          finish - start <= 25.hours
+        end
       end
     end
   end

data/app/models/rails_pulse/dashboard/health_summary.rb

@@ -4,12 +4,13 @@ module RailsPulse
       include Concerns::ThresholdConstants
       include Concerns::TimeRangeHelper
 
-      def initialize(disabled_tags: [], show_non_tagged: true, period: 7, start_time: nil, end_time: nil)
+      def initialize(disabled_tags: [], show_non_tagged: true, period: 7, period_type: nil, window: nil, storage_pressure: nil)
         @disabled_tags   = disabled_tags
         @show_non_tagged = show_non_tagged
         @period          = period
-        @start_time      = start_time
-        @end_time        = end_time
+        @period_type     = period_type
+        @window          = window
+        @storage_pressure = storage_pressure
         @route_thresholds = RailsPulse.configuration.route_thresholds
         @query_thresholds = RailsPulse.configuration.query_thresholds
         @job_thresholds   = RailsPulse.configuration.job_thresholds
@@ -22,6 +23,7 @@ module RailsPulse
           queries:  query_counts,
           jobs:     job_counts,
           exceptions: exception_counts,
+          tracking: tracking_counts,
           storage:  storage_counts
         }
       end
@@ -29,11 +31,10 @@ module RailsPulse
       private
 
       def route_counts
-        start, finish = period_range
-
         data = RailsPulse::Summary
           .with_tag_filters(@disabled_tags, @show_non_tagged)
-          .where(summarizable_type: "RailsPulse::Route", period_start: start..finish)
+          .where(summarizable_type: "RailsPulse::Route")
+          .merge(period_summaries)
           .group("summarizable_id")
           .select(
             "summarizable_id",
@@ -62,11 +63,10 @@ module RailsPulse
       end
 
       def query_counts
-        start, finish = period_range
-
         data = RailsPulse::Summary
           .with_tag_filters(@disabled_tags, @show_non_tagged)
-          .where(summarizable_type: "RailsPulse::Query", period_start: start..finish)
+          .where(summarizable_type: "RailsPulse::Query")
+          .merge(period_summaries)
           .group("summarizable_id")
           .select(
             "summarizable_id",
@@ -90,7 +90,34 @@ module RailsPulse
       end
 
       def storage_counts
-        StoragePressure.new.storage_counts
+        (@storage_pressure || StoragePressure.new).storage_counts
+      end
+
+      # A process that dropped and has since gone away still counts as
+      # critical for that hour. Nil until any writer has reported.
+      def tracking_counts
+        return nil unless RailsPulse::Event.table_available?
+
+        live = RailsPulse::WriterHeartbeat.live_processes
+        dropped_by_process = RailsPulse::WriterHeartbeat.dropped_by_process(window: 1.hour).select { |_, n| n.positive? }
+        return nil if live.empty? && dropped_by_process.empty?
+
+        critical = dropped_by_process.size
+        healthy = slow = 0
+        live.each do |process|
+          next if dropped_by_process.key?(process.process_label)
+
+          # queue_size <= 0 means unreadable metadata, not an empty queue
+          if process.queue_size <= 0
+            critical += 1
+          elsif process.queue_depth * 2 >= process.queue_size
+            slow += 1
+          else
+            healthy += 1
+          end
+        end
+
+        { healthy: healthy, slow: slow, critical: critical }
       end
 
       def job_counts
@@ -125,12 +152,10 @@ module RailsPulse
         return nil unless RailsPulse.configuration.track_exceptions
         return nil unless exception_summaries_available?
 
-        start, finish = period_range
-
         counts = RailsPulse::Summary
           .for_exceptions
           .where.not(summarizable_id: 0)
-          .where(period_start: start..finish)
+          .merge(period_summaries)
           .group(:summarizable_id)
           .sum(:count)
 

data/app/models/rails_pulse/dashboard/needs_attention.rb

@@ -1,15 +1,16 @@
 module RailsPulse
   module Dashboard
     class NeedsAttention
-      include Concerns::ThresholdConstants
+      include Concerns::AttentionClassification
       include Concerns::TimeRangeHelper
 
-      def initialize(disabled_tags: [], show_non_tagged: true, period: 7, start_time: nil, end_time: nil)
+      def initialize(disabled_tags: [], show_non_tagged: true, period: 7, period_type: nil, window: nil, storage_pressure: nil)
         @disabled_tags    = disabled_tags
         @show_non_tagged  = show_non_tagged
         @period           = period
-        @start_time       = start_time
-        @end_time         = end_time
+        @period_type      = period_type
+        @window           = window
+        @storage_pressure = storage_pressure
         @route_thresholds = RailsPulse.configuration.route_thresholds
         @query_thresholds = RailsPulse.configuration.query_thresholds
         @job_thresholds   = RailsPulse.configuration.job_thresholds
@@ -41,7 +42,18 @@ module RailsPulse
       private
 
       def storage_pressure_items
-        StoragePressure.new.pressure_items
+        (@storage_pressure || StoragePressure.new).pressure_items
+      end
+
+      # The dashboard window is user-selected, so the error-rate reason names
+      # the window's real length rather than assuming a week.
+      def span_phrase
+        start, finish = period_range
+        hours = ((finish - start) / 1.hour).round
+        return "in the last #{hours} hour#{"s" unless hours == 1}" if hours <= 25
+
+        days = (hours / 24.0).round
+        "in the last #{days} day#{"s" unless days == 1}"
       end
 
       def url_helpers
@@ -49,12 +61,11 @@ module RailsPulse
       end
 
       def route_items
-        start, finish = period_range
-
         route_data = RailsPulse::Summary
           .with_tag_filters(@disabled_tags, @show_non_tagged)
           .joins("INNER JOIN rails_pulse_routes ON rails_pulse_routes.id = rails_pulse_summaries.summarizable_id")
-          .where(summarizable_type: "RailsPulse::Route", period_start: start..finish)
+          .where(summarizable_type: "RailsPulse::Route")
+          .merge(period_summaries)
           .group("rails_pulse_summaries.summarizable_id, rails_pulse_routes.path")
           .select(
             "rails_pulse_summaries.summarizable_id as route_id",
@@ -71,7 +82,7 @@ module RailsPulse
           errors     = record.total_errors.to_i
           error_rate = total > 0 ? (errors * 100.0 / total).round(1) : 0.0
 
-          severity, reason, metric, metric_sub, sort_score = classify_route(p95, total, errors, error_rate)
+          severity, reason, metric, metric_sub, sort_score = classify_route(p95, total, errors, error_rate, span_phrase)
           next unless severity
 
           items << {
@@ -89,45 +100,12 @@ module RailsPulse
         items
       end
 
-      def classify_route(p95, total, errors, error_rate)
-        if p95 >= @route_thresholds[:critical] || error_rate >= CRITICAL_ERROR_RATE
-          if error_rate >= CRITICAL_ERROR_RATE
-            [ :critical,
-              "#{error_rate}% error rate · #{total} requests this week",
-              "#{errors} errors",
-              "P95 #{p95.round(0).to_i}ms",
-              errors * total.to_f ]
-          else
-            [ :critical,
-              "#{p95.round(0).to_i}ms P95 · exceeds #{@route_thresholds[:critical]}ms threshold",
-              "#{p95.round(0).to_i}ms P95",
-              "#{total} requests",
-              p95 ]
-          end
-        elsif p95 >= @route_thresholds[:slow] || error_rate >= WARNING_ERROR_RATE
-          if error_rate >= WARNING_ERROR_RATE && p95 < @route_thresholds[:slow]
-            [ :warning,
-              "#{error_rate}% error rate · #{total} requests this week",
-              "#{errors} errors",
-              "P95 #{p95.round(0).to_i}ms",
-              errors * total.to_f ]
-          else
-            [ :warning,
-              "#{p95.round(0).to_i}ms P95 · #{error_rate > 0 ? "#{error_rate}% error rate" : "above slow threshold"}",
-              "#{p95.round(0).to_i}ms P95",
-              "#{total} requests",
-              p95 ]
-          end
-        end
-      end
-
       def query_items
-        start, finish = period_range
-
         query_data = RailsPulse::Summary
           .with_tag_filters(@disabled_tags, @show_non_tagged)
           .joins("INNER JOIN rails_pulse_queries ON rails_pulse_queries.id = rails_pulse_summaries.summarizable_id")
-          .where(summarizable_type: "RailsPulse::Query", period_start: start..finish)
+          .where(summarizable_type: "RailsPulse::Query")
+          .merge(period_summaries)
           .group("rails_pulse_summaries.summarizable_id, rails_pulse_queries.normalized_sql")
           .select(
             "rails_pulse_summaries.summarizable_id as query_id",
@@ -143,26 +121,19 @@ module RailsPulse
           p95   = record.p95_duration.to_f
           count = record.total_count.to_i
 
-          if p95 >= @query_thresholds[:critical]
-            severity = :critical
-            reason   = "#{p95.round(0).to_i}ms P95 · exceeds #{@query_thresholds[:critical]}ms threshold"
-          elsif p95 >= @query_thresholds[:slow]
-            severity = :warning
-            reason   = "#{p95.round(0).to_i}ms P95 · above #{@query_thresholds[:slow]}ms slow threshold"
-          else
-            next
-          end
+          severity, reason, metric, metric_sub, sort_score = classify_query(p95, count)
+          next unless severity
 
           classified_ids << record.query_id
           items << {
             type:       "QUERY",
             name:       truncate_sql(record.normalized_sql),
             reason:     reason,
-            metric:     "#{p95.round(0).to_i}ms P95",
-            metric_sub: "#{count} execution#{count == 1 ? "" : "s"}",
+            metric:     metric,
+            metric_sub: metric_sub,
             link:       url_helpers.query_path(record.query_id),
             severity:   severity,
-            sort_score: p95,
+            sort_score: sort_score,
             monospace:  true
           }
         end
@@ -200,7 +171,9 @@ module RailsPulse
           failure_rate = job.failure_rate
           p95          = job.p95_duration.to_f
 
-          severity, reason, metric, metric_sub, sort_score = classify_job(job, failure_rate, p95)
+          severity, reason, metric, metric_sub, sort_score = classify_job(
+            failure_rate, p95, job.runs_count, job.failures_count, job.queue_name.presence || "default"
+          )
           next unless severity
 
           items << {
@@ -218,38 +191,6 @@ module RailsPulse
         items
       end
 
-      def classify_job(job, failure_rate, p95)
-        if failure_rate >= CRITICAL_JOB_FAILURE_RATE || p95 >= @job_thresholds[:critical]
-          if failure_rate >= CRITICAL_JOB_FAILURE_RATE
-            [ :critical,
-              "#{job.queue_name.presence || "default"} queue · #{failure_rate}% failure rate",
-              "#{job.failures_count} / #{job.runs_count} failed",
-              "P95 #{p95.round(0).to_i}ms",
-              job.failures_count * job.runs_count.to_f ]
-          else
-            [ :critical,
-              "P95 #{p95.round(0).to_i}ms · exceeds #{@job_thresholds[:critical]}ms threshold",
-              "#{p95.round(0).to_i}ms P95",
-              "#{job.runs_count} runs",
-              p95 ]
-          end
-        elsif failure_rate >= WARNING_JOB_FAILURE_RATE || p95 >= @job_thresholds[:slow]
-          if failure_rate >= WARNING_JOB_FAILURE_RATE
-            [ :warning,
-              "#{job.queue_name.presence || "default"} queue · #{failure_rate}% failure rate",
-              "#{job.failures_count} / #{job.runs_count} failed",
-              "P95 #{p95.round(0).to_i}ms",
-              job.failures_count * job.runs_count.to_f ]
-          else
-            [ :warning,
-              "P95 #{p95.round(0).to_i}ms · above slow threshold",
-              "#{p95.round(0).to_i}ms P95",
-              "#{job.runs_count} runs",
-              p95 ]
-          end
-        end
-      end
-
       # Exception groups that fired often enough over the period to be worth
       # looking at. Read from summaries, not from ExceptionGroup#occurrence_count
       # — that is a lifetime counter, so a group that was noisy last year and is
@@ -262,12 +203,10 @@ module RailsPulse
         return [] unless RailsPulse.configuration.track_exceptions
         return [] unless exception_tables_available?
 
-        start, finish = period_range
-
         counts = RailsPulse::Summary
           .for_exceptions
           .where.not(summarizable_id: 0)
-          .where(period_start: start..finish)
+          .merge(period_summaries)
           .group(:summarizable_id)
           .sum(:count)
 
@@ -320,12 +259,6 @@ module RailsPulse
       rescue ActiveRecord::ActiveRecordError
         false
       end
-
-      def truncate_sql(sql)
-        return "" if sql.blank?
-        cleaned = sql.gsub(/\s+/, " ").strip
-        cleaned.length > 80 ? "#{cleaned[0..79]}..." : cleaned
-      end
     end
   end
 end

data/app/models/rails_pulse/dashboard/storage_pressure.rb

@@ -8,12 +8,15 @@ module RailsPulse
         @config = RailsPulse.configuration
       end
 
+      # Memoized: computing the items costs several aggregate queries (one a
+      # raw-request count), and one dashboard render asks for them repeatedly.
       def pressure_items
-        summary_staleness_items + stuck_records_items + sub_hour_retention_items
+        @pressure_items ||= summary_staleness_items + sub_hour_retention_items + writer_drop_items
       end
 
+      # Dropped requests get their own Tracking badge, not this one
       def storage_counts
-        items    = pressure_items
+        items    = pressure_items.reject { |i| i[:type] == "TRACKING" }
         critical = items.any? { |i| i[:severity] == :critical } ? 1 : 0
         slow     = (critical.zero? && items.any? { |i| i[:severity] == :warning }) ? 1 : 0
         healthy  = (critical.zero? && slow.zero?) ? 1 : 0
@@ -36,53 +39,17 @@ module RailsPulse
         if age >= STALE_CRITICAL_THRESHOLD
           hours = (age / 1.hour).round
           [ stale_item(:critical, "Summary job is #{hours}h behind",
-                       "#{hours}h stale", "Last run: #{latest_end.strftime("%Y-%m-%d %H:%M UTC")}") ]
+                       "#{hours}h stale", "Last run: #{latest_end.strftime("%Y-%m-%d %H:%M")} (#{RailsPulse::TimeRange.aggregation_zone_label})") ]
         elsif age >= STALE_WARNING_THRESHOLD
           hours = (age / 1.hour).round
           [ stale_item(:warning, "Summary job is #{hours}h behind",
-                       "#{hours}h stale", "Last run: #{latest_end.strftime("%Y-%m-%d %H:%M UTC")}") ]
+                       "#{hours}h stale", "Last run: #{latest_end.strftime("%Y-%m-%d %H:%M")} (#{RailsPulse::TimeRange.aggregation_zone_label})") ]
         else
           []
         end
       end
 
-      # Signal B — Records past retention that haven't been summarized (cleanup is blocked)
-      def stuck_records_items
-        return [] unless @config.archiving_enabled
-        return [] unless @config.full_retention_period
-
-        oldest_start = oldest_overall_request_summary_start
-        return [] if oldest_start.nil?
-
-        stuck_count = RailsPulse::Request
-          .where("occurred_at < ?", @config.full_retention_period.ago)
-          .where("occurred_at < ?", oldest_start)
-          .count
-
-        return [] if stuck_count.zero?
-
-        [ {
-          type:          "STORAGE",
-          name:          "Storage pressure",
-          reason:        "#{stuck_count} #{"request".pluralize(stuck_count)} past the retention window cannot be cleaned up — summarize first",
-          metric:        "#{stuck_count} stuck",
-          metric_sub:    "older than #{humanize_duration(@config.full_retention_period)}",
-          link:          "#",
-          severity:      :critical,
-          sort_score:    stuck_count.to_f,
-          popover_title: "Cleanup is blocked on unsummarised records",
-          popover_body:  "#{stuck_count} #{"request".pluralize(stuck_count)} are older than your retention period " \
-                         "(#{humanize_duration(@config.full_retention_period)}) but predate any hourly summary record. " \
-                         "CleanupService will not delete records from a time period until that period has been summarised — " \
-                         "otherwise those data points would be permanently lost from dashboard charts.<br><br>" \
-                         "<strong>How to fix:</strong> Run <code>RailsPulse::SummaryJob</code> to summarise the historical periods. " \
-                         "If the job is not yet scheduled, run the backfill task to summarise all historical data:<br><br>" \
-                         "<code>rails rails_pulse:backfill_summaries</code><br><br>" \
-                         "Once the affected periods are summarised, the next cleanup run will delete these records automatically."
-        } ]
-      end
-
-      # Signal C — Retention period shorter than 1-hour cleanup minimum
+      # Signal B — Retention period shorter than 1-hour cleanup minimum
       def sub_hour_retention_items
         return [] unless @config.full_retention_period
         return [] unless @config.full_retention_period < 1.hour
@@ -107,6 +74,35 @@ module RailsPulse
         } ]
       end
 
+      # Signal C — the background writer is discarding requests
+      def writer_drop_items
+        return [] unless RailsPulse::Event.table_available?
+
+        summary = RailsPulse::WriterHeartbeat.summary
+        dropped = summary[:dropped].to_i
+        return [] if dropped.zero?
+
+        [ {
+          type:          "TRACKING",
+          name:          "Writer queue dropping requests",
+          reason:        "#{dropped} #{"request".pluralize(dropped)} dropped in the last hour — charts are missing samples",
+          metric:        "#{dropped} dropped",
+          metric_sub:    "last hour, #{summary[:processes]} live #{"writer".pluralize(summary[:processes])}",
+          link:          "#",
+          severity:      :critical,
+          sort_score:    dropped.to_f,
+          popover_title: "The tracking queue is overflowing",
+          popover_body:  "Each process queues tracked requests for one background writer. When the queue (#{summary[:queue_size]} requests, " \
+                         "<code>config.async_queue_size</code>) is full the newest request is dropped rather than slowing the app, so the " \
+                         "dashboard undercounts traffic while this lasts.<br><br>" \
+                         "<strong>How to fix:</strong> raise <code>config.async_queue_size</code> in the Rails Pulse initializer, or find out " \
+                         "why the writer cannot keep up: database latency, a saturated connection pool, or a burst far above normal traffic. " \
+                         "<code>rails rails_pulse:status</code> reports the same numbers from the shell."
+        } ]
+      rescue ActiveRecord::ActiveRecordError
+        []
+      end
+
       def stale_item(severity, reason, metric, metric_sub)
         {
           type:          "STORAGE",
@@ -118,8 +114,8 @@ module RailsPulse
           severity:      severity,
           sort_score:    severity == :critical ? Float::INFINITY : 1.0,
           popover_title: "Summary job is not running",
-          popover_body:  "Rails Pulse summarises raw request data into hourly aggregates before cleanup can safely delete them. " \
-                         "Until a period is summarised, CleanupService will not delete records from it — so your database will grow until the summary job catches up.<br><br>" \
+          popover_body:  "Rails Pulse summarises raw request data into hourly aggregates for the dashboard's charts. " \
+                         "Count-based cleanup only trims records from periods that have been summarised, so until the job catches up tables can grow past <code>max_table_records</code>.<br><br>" \
                          "<strong>How to fix:</strong> Schedule <code>RailsPulse::SummaryJob</code> to run every hour in your job scheduler " \
                          "(Sidekiq-Cron, GoodJob, Solid Queue, etc.). Once it has run, cleanup will resume automatically on its next execution.<br><br>" \
                          "To backfill any historical gaps, run: <code>rails rails_pulse:backfill_summaries</code>"
@@ -131,26 +127,6 @@ module RailsPulse
           .where(summarizable_type: "RailsPulse::Request", summarizable_id: 0, period_type: "hour")
           .maximum(:period_end)
       end
-
-      def oldest_overall_request_summary_start
-        RailsPulse::Summary
-          .where(summarizable_type: "RailsPulse::Request", summarizable_id: 0, period_type: "hour")
-          .minimum(:period_start)
-      end
-
-      def humanize_duration(duration)
-        total_seconds = duration.to_i
-        if total_seconds >= 86_400
-          days = total_seconds / 86_400
-          "#{days} #{"day".pluralize(days)}"
-        elsif total_seconds >= 3_600
-          hours = total_seconds / 3_600
-          "#{hours} #{"hour".pluralize(hours)}"
-        else
-          minutes = total_seconds / 60
-          "#{minutes} #{"minute".pluralize(minutes)}"
-        end
-      end
     end
   end
 end