rails_pulse 0.4.0.pre.4 → 0.4.0

data/app/controllers/rails_pulse/dashboard_controller.rb

@@ -8,8 +8,11 @@ module RailsPulse
       @start_time, @end_time, @selected_time_range, @time_diff = setup_time_range
       populate_deployment_markers
 
-      # Convert time range to period in days for dashboard cards/charts
-      @period = ((@end_time - @start_time) / 1.day).round
+      # Rounded rather than truncated, so a range a few seconds short of N
+      # whole days still counts as N. Cards/charts also get @start_time/
+      # @end_time directly so they bucket the exact range, not "the last
+      # @period days ending now".
+      @period = RailsPulse::TimeWindow.new(@start_time, @end_time).days
 
       # Determine period type based on time range
       # If 24 hours or less, use hourly summaries, otherwise use daily
@@ -19,22 +22,28 @@ module RailsPulse
       disabled_tags = session_disabled_tags
       show_non_tagged = session[:show_non_tagged] != false
 
-      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, period_type: @period_type).to_metric_card
-      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, period_type: @period_type).to_metric_card
-      @error_rates_metric_card = RailsPulse::Routes::Cards::ErrorRates.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, period_type: @period_type).to_metric_card
-      @job_failure_rate_metric_card = RailsPulse::Jobs::Cards::FailureRate.new(period: @period, period_type: @period_type).to_metric_card if RailsPulse.configuration.track_jobs
+      card_and_chart_options = {
+        disabled_tags: disabled_tags, show_non_tagged: show_non_tagged,
+        period: @period, period_type: @period_type,
+        start_time: @start_time, end_time: @end_time
+      }
+
+      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil, **card_and_chart_options).to_metric_card
+      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil, **card_and_chart_options).to_metric_card
+      @error_rates_metric_card = RailsPulse::Routes::Cards::ErrorRates.new(route: nil, **card_and_chart_options).to_metric_card
+      @job_failure_rate_metric_card = RailsPulse::Jobs::Cards::FailureRate.new(**card_and_chart_options).to_metric_card if RailsPulse.configuration.track_jobs
 
       # Generate chart data for inline rendering
-      @response_time_percentiles_chart_data = RailsPulse::Dashboard::Charts::ResponseTimePercentiles.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, period_type: @period_type).to_chart_data
-      @throughput_and_errors_chart_data = RailsPulse::Dashboard::Charts::ThroughputAndErrors.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, period_type: @period_type).to_chart_data
+      @response_time_percentiles_chart_data = RailsPulse::Dashboard::Charts::ResponseTimePercentiles.new(**card_and_chart_options).to_chart_data
+      @throughput_and_errors_chart_data = RailsPulse::Dashboard::Charts::ThroughputAndErrors.new(**card_and_chart_options).to_chart_data
 
       # Needs Attention panel
-      @needs_attention = RailsPulse::Dashboard::NeedsAttention.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period).to_attention_data
+      @needs_attention = RailsPulse::Dashboard::NeedsAttention.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, start_time: @start_time, end_time: @end_time).to_attention_data
 
       # System Health bar
-      @health_summary = RailsPulse::Dashboard::HealthSummary.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period).to_health_data
+      @health_summary = RailsPulse::Dashboard::HealthSummary.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, start_time: @start_time, end_time: @end_time).to_health_data
 
-      @storage_status = RailsPulse::Dashboard::StorageStatus.new
+      @storage_status = RailsPulse::Dashboard::StorageStatus.new(cached_sizes: true)
 
       # Deployments panel — scoped to the same window as the chart markers so
       # the panel and the markers drawn on the charts always agree.

data/app/controllers/rails_pulse/routes_controller.rb

@@ -14,6 +14,7 @@ module RailsPulse
     def show
       setup_metric_cards
       setup_chart_and_table_data
+      setup_archived_summary_data
     end
 
     private
@@ -126,6 +127,51 @@ module RailsPulse
       @route = Route.find(params[:id])
     end
 
+    ARCHIVED_SUMMARY_PAGE_LIMIT = 20
+
+    # Raw Request rows get purged by CleanupService after full_retention_period.
+    # For any part of the selected window older than that cutoff, fall back to
+    # pre-aggregated Summary rows (which CleanupService never deletes for
+    # day/week/month periods) so the table isn't just blank for old ranges.
+    def setup_archived_summary_data
+      cutoff = retention_cutoff
+      window_start = @page_timings&.table_start_time
+
+      scope = if cutoff && window_start && Time.at(window_start) < cutoff
+        scope = Summary.for_routes
+          .where(summarizable_id: @route.id)
+          .where(period_type: period_type)
+          .where("period_start < ?", cutoff)
+
+        if @page_timings&.table_end_time
+          scope = scope.where("period_start < ?", Time.at(@page_timings.table_end_time))
+        end
+
+        scope.order(period_start: :desc)
+      else
+        Summary.none
+      end
+
+      @archived_pagination, @archived_summary_data =
+        paginate_archived(scope, limit: ARCHIVED_SUMMARY_PAGE_LIMIT)
+    end
+
+    # Mirrors PaginationConcern#paginate but keys off its own `archived_page`
+    # param so the archived table's pagination doesn't fight over the same
+    # `page`/`limit` params as the live requests table above it on the page.
+    def paginate_archived(collection, limit:)
+      page = [ params[:archived_page].to_i, 1 ].max
+      paginator = RailsPulse::Paginator.new(count: collection.count(:all), page: page, limit: limit)
+      records = collection.offset((paginator.page - 1) * limit).limit(limit)
+      [ paginator, records ]
+    end
+
+    def retention_cutoff
+      config = RailsPulse.configuration rescue nil
+      period = config&.full_retention_period
+      period ? period.ago : nil
+    end
+
     def ordering_by_computed_column?
       # Check if we're ordering by status_indicator (computed column)
       @ransack_query.sorts.any? { |sort| sort.name == "status_indicator" }

data/app/helpers/rails_pulse/application_helper.rb

@@ -31,5 +31,9 @@ module RailsPulse
     def page_url(page_number)
       url_for(request.query_parameters.merge(page: page_number))
     end
+
+    def archived_page_url(page_number)
+      url_for(request.query_parameters.merge(archived_page: page_number, anchor: "archived-data"))
+    end
   end
 end

data/app/javascript/rails_pulse/controllers/chart_controller.js

@@ -160,6 +160,12 @@ export default class extends Controller {
       config.xAxis = config.xAxis || {}
       if (isTimePairs) {
         config.xAxis.type = 'time'
+        // Without this, ECharts spaces ticks by pixel width, not by the data's
+        // actual bucket size — a multi-day "time" axis can end up with more
+        // ticks than days, and since the label formatter only shows the date,
+        // adjacent ticks on the same day render as duplicate-looking labels.
+        const bucketMs = this._minTimestampGapMs(data.series)
+        if (bucketMs) config.xAxis.minInterval = bucketMs
       } else {
         config.xAxis.type = 'category'
         config.xAxis.data = data.labels
@@ -240,6 +246,27 @@ export default class extends Controller {
     return Array.isArray(firstPoint) || Array.isArray(firstPoint?.value)
   }
 
+  // Smallest gap (ms) between any two distinct timestamps across all series,
+  // used as xAxis.minInterval so auto-placed ticks never fall closer together
+  // than the data actually does.
+  _minTimestampGapMs(series) {
+    const timestamps = new Set()
+    series.forEach(s => {
+      (s.data || []).forEach(point => {
+        const pair = Array.isArray(point) ? point : (Array.isArray(point?.value) ? point.value : null)
+        if (pair && typeof pair[0] === 'number') timestamps.add(pair[0])
+      })
+    })
+
+    const sorted = Array.from(timestamps).sort((a, b) => a - b)
+    let minGap = null
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i] - sorted[i - 1]
+      if (gap > 0 && (minGap === null || gap < minGap)) minGap = gap
+    }
+    return minGap
+  }
+
   deploymentMarkerSeriesId = 'rails-pulse-deployment-markers'
 
   _buildDeploymentMarkerSeries(markers, visible = true) {

data/app/models/rails_pulse/cards/base.rb

@@ -5,12 +5,20 @@ module RailsPulse
     class Base
       private
 
+      # nil unless the caller passed both start_time and end_time, so the
+      # "trailing @period days/hours" fallback below still applies by default.
+      def time_window
+        return @time_window if defined?(@time_window)
+
+        @time_window = RailsPulse::TimeWindow.build(@start_time, @end_time)
+      end
+
       def now
-        @now ||= Time.current
+        @now ||= time_window&.end_time || Time.current
       end
 
       def window_days
-        @period || 7
+        time_window&.days || @period || 7
       end
 
       def period_type_hours?
@@ -19,7 +27,9 @@ module RailsPulse
 
       # Enhanced time period helpers (support hour and day)
       def previous_window_start
-        if period_type_hours?
+        if time_window
+          time_window.previous(period_type_hours? ? "hour" : "day").start_time
+        elsif period_type_hours?
           (now - (window_days * 48).hours).beginning_of_hour
         else
           (now - (window_days * 2).days).beginning_of_day
@@ -27,7 +37,9 @@ module RailsPulse
       end
 
       def current_window_start
-        if period_type_hours?
+        if time_window
+          time_window.start_time
+        elsif period_type_hours?
           (now - (window_days * 24).hours).beginning_of_hour
         else
           (now - window_days.days).beginning_of_day
@@ -82,26 +94,15 @@ module RailsPulse
       end
 
       def build_hourly_sparkline(grouped_values)
-        start_time = sparkline_start
-        end_time = now.beginning_of_hour
-
-        {}.tap do |hash|
-          current_time = start_time
-          while current_time <= end_time
-            # Use timestamp in milliseconds for JS compatibility
-            hash[current_time.to_i * 1000] = { value: grouped_values[current_time] || 0 }
-            current_time += 1.hour
-          end
+        sparkline_hours.each_with_object({}) do |current_time, hash|
+          # Use timestamp in milliseconds for JS compatibility
+          hash[current_time.to_i * 1000] = { value: grouped_values[current_time] || 0 }
         end
       end
 
       def build_daily_sparkline(grouped_values)
-        start_date = sparkline_start.to_date
-        end_date = now.to_date
-
-        (start_date..end_date).each_with_object({}) do |day, hash|
-          label = day.strftime("%b %-d")
-          hash[label] = { value: grouped_values[day] || 0 }
+        sparkline_dates.each_with_object({}) do |day, hash|
+          hash[day.strftime("%b %-d")] = { value: grouped_values[day] || 0 }
         end
       end
 
@@ -112,6 +113,27 @@ module RailsPulse
         current_window_start
       end
 
+      # Every calendar date in the sparkline window. Via TimeWindow, so a
+      # range not starting on a day boundary skips the leading partial day.
+      def sparkline_dates
+        time_window&.dates || (sparkline_start.to_date..now.to_date).to_a
+      end
+
+      # Same skip-partial semantics as sparkline_dates, for hours.
+      def sparkline_hours
+        time_window&.hour_starts || begin
+          start_time = sparkline_start.beginning_of_hour
+          end_time = now.beginning_of_hour
+          hours = []
+          current_time = start_time
+          while current_time <= end_time
+            hours << current_time
+            current_time += 1.hour
+          end
+          hours
+        end
+      end
+
       # Build sparkline query with tag filters and optional subject filter
       def build_sparkline_query(summarizable_type)
         sparkline_query = RailsPulse::Summary
@@ -127,15 +149,29 @@ module RailsPulse
 
       # Group sparkline query by period type (hour or day)
       def group_sparkline_by_period(sparkline_query, sum_field)
-        if period_type_hours?
-          sparkline_query.group_by_hour(:period_start).sum(sum_field)
-        else
-          sparkline_query.group_by_date(:period_start).sum(sum_field)
+        bucket_by_period(sparkline_query) { |relation| relation.sum(sum_field) }
+      end
+
+      # Aggregates `relation` per calendar day of Time.zone, or per hour when
+      # the card's period type is "hour". The block receives the relation
+      # grouped by `column` and does the arithmetic in SQL; only the
+      # re-bucketing of keys happens here. It is done in Ruby because SQL
+      # DATE() / DATE_TRUNC() operate on the stored UTC value, which puts a
+      # Melbourne midnight on the previous calendar date and a Kolkata hour
+      # thirty minutes off, so the sparkline lookups (keyed by Time.zone
+      # dates and hour starts) would miss.
+      def bucket_by_period(relation, column: :period_start)
+        yield(relation.group(column)).each_with_object({}) do |(time, value), buckets|
+          next if time.nil? || value.nil?
+
+          local = time.in_time_zone
+          key = period_type_hours? ? local.beginning_of_hour : local.to_date
+          buckets[key] = (buckets[key] || 0) + value
         end
       end
 
       def period_date_range
-        start_date = current_window_start.to_date
+        start_date = sparkline_dates.first || current_window_start.to_date
         end_date = now.to_date
         if start_date.year == end_date.year
           "#{start_date.strftime("%b %-d")} – #{end_date.strftime("%b %-d")}"

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

@@ -2,18 +2,21 @@ module RailsPulse
   module Dashboard
     module Charts
       class ResponseTimePercentiles
-        def initialize(disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day")
+        def initialize(disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: 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
         end
 
         def to_chart_data
           if @period_type == "hour"
-            # Create a range of all hours in the selected period
-            start_time = (@period * 24).hours.ago.beginning_of_hour
-            end_time = Time.current.beginning_of_hour
+            # Exact selected hours when explicit, else "trailing @period days".
+            hours = time_window&.hour_starts || default_hour_range
+            start_time = hours.first
+            end_time = hours.last
 
             # Get the actual data from Summary records (routes)
             summaries = RailsPulse::Summary
@@ -56,13 +59,7 @@ module RailsPulse
               }
             end
 
-            # Build hourly time range
-            time_range = []
-            current_time = start_time
-            while current_time <= end_time
-              time_range << current_time
-              current_time += 1.hour
-            end
+            time_range = hours
 
             # Build series data as [timestamp_ms, value] pairs for ECharts time axis
             timestamps_ms = time_range.map { |t| t.to_i * 1000 }
@@ -70,10 +67,10 @@ module RailsPulse
             p95_data = time_range.map { |time| [ time.to_i * 1000, final_data[time]&.[](:p95) ] }
             p99_data = time_range.map { |time| [ time.to_i * 1000, final_data[time]&.[](:p99) ] }
           else
-            # Daily grouping (existing logic)
-            start_date = @period.days.ago.beginning_of_day.to_date
-            end_date = Time.current.to_date
-            date_range = (start_date..end_date)
+            # Exact selected days when explicit, else "trailing @period days".
+            date_range = time_window&.dates || default_day_range
+            start_date = date_range.first
+            end_date = date_range.last
 
             summaries = RailsPulse::Summary
               .with_tag_filters(@disabled_tags, @show_non_tagged)
@@ -169,6 +166,32 @@ module RailsPulse
             { labels: labels, series: series }
           end
         end
+
+        private
+
+        # nil unless both start_time and end_time were 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)
+        end
+
+        def default_hour_range
+          start_time = (@period * 24).hours.ago.beginning_of_hour
+          end_time = Time.current.beginning_of_hour
+          hours = []
+          current_time = start_time
+          while current_time <= end_time
+            hours << current_time
+            current_time += 1.hour
+          end
+          hours
+        end
+
+        def default_day_range
+          start_date = @period.days.ago.beginning_of_day.to_date
+          end_date = Time.current.to_date
+          (start_date..end_date).to_a
+        end
       end
     end
   end

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

@@ -2,17 +2,20 @@ module RailsPulse
   module Dashboard
     module Charts
       class ThroughputAndErrors
-        def initialize(disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day")
+        def initialize(disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: 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
         end
 
         def to_chart_data
           if @period_type == "hour"
-            start_time = (@period * 24).hours.ago.beginning_of_hour
-            end_time = Time.current.beginning_of_hour
+            hours = time_window&.hour_starts || default_hour_range
+            start_time = hours.first
+            end_time = hours.last
 
             summaries = RailsPulse::Summary
               .with_tag_filters(@disabled_tags, @show_non_tagged)
@@ -40,13 +43,7 @@ module RailsPulse
               }
             end
 
-            # Build hourly time range
-            time_range = []
-            current_time = start_time
-            while current_time <= end_time
-              time_range << current_time
-              current_time += 1.hour
-            end
+            time_range = hours
 
             series = [
               {
@@ -70,9 +67,9 @@ module RailsPulse
 
             return { series: series }
           else
-            start_date = @period.days.ago.beginning_of_day.to_date
-            end_date = Time.current.to_date
-            date_range = (start_date..end_date)
+            date_range = time_window&.dates || default_day_range
+            start_date = date_range.first
+            end_date = date_range.last
 
             summaries = RailsPulse::Summary
               .with_tag_filters(@disabled_tags, @show_non_tagged)
@@ -125,6 +122,32 @@ module RailsPulse
 
           { labels: labels, series: series }
         end
+
+        private
+
+        # nil unless both start_time and end_time were 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)
+        end
+
+        def default_hour_range
+          start_time = (@period * 24).hours.ago.beginning_of_hour
+          end_time = Time.current.beginning_of_hour
+          hours = []
+          current_time = start_time
+          while current_time <= end_time
+            hours << current_time
+            current_time += 1.hour
+          end
+          hours
+        end
+
+        def default_day_range
+          start_date = @period.days.ago.beginning_of_day.to_date
+          end_date = Time.current.to_date
+          (start_date..end_date).to_a
+        end
       end
     end
   end

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

@@ -5,6 +5,9 @@ module RailsPulse
         private
 
         def period_range
+          window = RailsPulse::TimeWindow.build(@start_time, @end_time)
+          return [ window.start_time, window.end_time ] if window
+
           [ @period.days.ago.beginning_of_day, Time.current ]
         end
       end

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

@@ -4,10 +4,12 @@ module RailsPulse
       include Concerns::ThresholdConstants
       include Concerns::TimeRangeHelper
 
-      def initialize(disabled_tags: [], show_non_tagged: true, period: 7)
+      def initialize(disabled_tags: [], show_non_tagged: true, period: 7, start_time: nil, end_time: nil)
         @disabled_tags   = disabled_tags
         @show_non_tagged = show_non_tagged
         @period          = period
+        @start_time      = start_time
+        @end_time        = end_time
         @route_thresholds = RailsPulse.configuration.route_thresholds
         @query_thresholds = RailsPulse.configuration.query_thresholds
         @job_thresholds   = RailsPulse.configuration.job_thresholds

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

@@ -4,10 +4,12 @@ module RailsPulse
       include Concerns::ThresholdConstants
       include Concerns::TimeRangeHelper
 
-      def initialize(disabled_tags: [], show_non_tagged: true, period: 7)
+      def initialize(disabled_tags: [], show_non_tagged: true, period: 7, start_time: nil, end_time: nil)
         @disabled_tags    = disabled_tags
         @show_non_tagged  = show_non_tagged
         @period           = period
+        @start_time       = start_time
+        @end_time         = end_time
         @route_thresholds = RailsPulse.configuration.route_thresholds
         @query_thresholds = RailsPulse.configuration.query_thresholds
         @job_thresholds   = RailsPulse.configuration.job_thresholds

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

@@ -74,51 +74,35 @@ module RailsPulse
         }
       ].freeze
 
-      # One-off screenshot fixture. Set SCREENSHOT to false (or delete this block) when done.
-      SCREENSHOT = !Rails.env.test?
-      SCREENSHOT_STATE = :warning # :healthy, :warning, :critical
-      SCREENSHOT_TABLES = {
-        healthy: {
-          rails_pulse_operations:            { count: 42_180,  limit: 100_000, recent: 3_140, bytes: 100_663_296, days_old: 14 },
-          rails_pulse_requests:              { count: 18_420,  limit: 50_000,  recent: 1_280, bytes: 42_991_616,  days_old: 14 },
-          rails_pulse_job_runs:              { count: 12_104,  limit: 50_000,  recent: 890,   bytes: 29_360_128,  days_old: 14 },
-          rails_pulse_exception_occurrences: { count: 1_842,   limit: 50_000,  recent: 22,    bytes: 11_534_336,  days_old: 14 },
-          rails_pulse_summaries:             { count: 1_128,   limit: nil,     recent: 48,    bytes: 4_403_200,   days_old: 14 },
-          rails_pulse_queries:               { count: 486,     limit: 10_000,  recent: 6,     bytes: 2_202_010,   days_old: 62 },
-          rails_pulse_routes:                { count: 214,     limit: 1_000,   recent: 1,     bytes: 421_888,     days_old: 62 },
-          rails_pulse_jobs:                  { count: 38,      limit: 1_000,   recent: 0,     bytes: 98_304,      days_old: 62 },
-          rails_pulse_exception_groups:      { count: 64,      limit: 10_000,  recent: 2,     bytes: 184_320,     days_old: 62 },
-          rails_pulse_deployments:           { count: 12,      limit: nil,     recent: 0,     bytes: 49_152,      days_old: 48 }
-        },
-        warning: {
-          rails_pulse_operations:            { count: 78_410,  limit: 100_000, recent: 6_820, bytes: 176_160_768, days_old: 14 },
-          rails_pulse_requests:              { count: 36_210,  limit: 50_000,  recent: 2_410, bytes: 81_788_928,  days_old: 14 },
-          rails_pulse_job_runs:              { count: 31_002,  limit: 50_000,  recent: 1_940, bytes: 54_525_952,  days_old: 14 },
-          rails_pulse_exception_occurrences: { count: 4_118,   limit: 50_000,  recent: 40,    bytes: 18_874_368,  days_old: 14 },
-          rails_pulse_summaries:             { count: 1_240,   limit: nil,     recent: 48,    bytes: 4_612_096,   days_old: 14 },
-          rails_pulse_queries:               { count: 812,     limit: 10_000,  recent: 12,    bytes: 3_250_176,   days_old: 90 },
-          rails_pulse_routes:                { count: 268,     limit: 1_000,   recent: 2,     bytes: 491_520,     days_old: 90 },
-          rails_pulse_jobs:                  { count: 41,      limit: 1_000,   recent: 0,     bytes: 106_496,     days_old: 90 },
-          rails_pulse_exception_groups:      { count: 91,      limit: 10_000,  recent: 3,     bytes: 225_280,     days_old: 90 },
-          rails_pulse_deployments:           { count: 18,      limit: nil,     recent: 1,     bytes: 65_536,      days_old: 90 }
-        },
-        critical: {
-          rails_pulse_operations:            { count: 104_280, limit: 100_000, recent: 8_110, bytes: 224_395_264, days_old: 18 },
-          rails_pulse_requests:              { count: 48_902,  limit: 50_000,  recent: 3_040, bytes: 106_954_752, days_old: 18 },
-          rails_pulse_job_runs:              { count: 46_118,  limit: 50_000,  recent: 2_280, bytes: 84_934_656,  days_old: 18 },
-          rails_pulse_exception_occurrences: { count: 8_640,   limit: 50_000,  recent: 90,    bytes: 25_165_824,  days_old: 18 },
-          rails_pulse_summaries:             { count: 1_410,   limit: nil,     recent: 24,    bytes: 5_033_984,   days_old: 18 },
-          rails_pulse_queries:               { count: 1_204,   limit: 10_000,  recent: 18,    bytes: 4_300_800,   days_old: 120 },
-          rails_pulse_routes:                { count: 312,     limit: 1_000,   recent: 4,     bytes: 552_960,     days_old: 120 },
-          rails_pulse_jobs:                  { count: 44,      limit: 1_000,   recent: 0,     bytes: 114_688,     days_old: 120 },
-          rails_pulse_exception_groups:      { count: 128,     limit: 10_000,  recent: 5,     bytes: 286_720,     days_old: 120 },
-          rails_pulse_deployments:           { count: 22,      limit: nil,     recent: 1,     bytes: 73_728,      days_old: 120 }
-        }
-      }.freeze
+      # Table sizes come from dbstat / pg_total_relation_size /
+      # information_schema, one statement per table. The dashboard only shows
+      # a headline total, so it reads them through a short-lived per-process
+      # cache; the Storage page itself always measures afresh.
+      SIZE_CACHE_TTL = 5.minutes
+      @size_cache = {}
+      @size_cache_mutex = Mutex.new
+
+      class << self
+        def cached_table_bytes(table_name)
+          @size_cache_mutex.synchronize do
+            entry = @size_cache[table_name]
+            return entry[:bytes] if entry && entry[:measured_at] > SIZE_CACHE_TTL.ago
+
+            bytes = yield
+            @size_cache[table_name] = { bytes: bytes, measured_at: Time.current }
+            bytes
+          end
+        end
 
-      def initialize
+        def reset_size_cache!
+          @size_cache_mutex.synchronize { @size_cache.clear }
+        end
+      end
+
+      def initialize(cached_sizes: false)
         @config = RailsPulse.configuration
         @pressure = StoragePressure.new
+        @cached_sizes = cached_sizes
       end
 
       def tables
@@ -178,33 +162,13 @@ module RailsPulse
         RailsPulse::ApplicationRecord.connection
       end
 
-      def screenshot_row(table_name)
-        return unless SCREENSHOT
-
-        row = SCREENSHOT_TABLES.dig(SCREENSHOT_STATE, table_name)
-        return unless row
-
-        oldest_at = row[:days_old].days.ago
-        {
-          count: row[:count],
-          limit: row[:limit],
-          recent_count: row[:recent],
-          bytes: row[:bytes],
-          oldest_at: oldest_at,
-          newest_at: 8.minutes.ago
-        }
-      end
-
       def build_table(definition)
-        screenshot = screenshot_row(definition[:name])
-        unless screenshot
-          model = definition[:model].safe_constantize
-          return unless model
-          return unless connection.table_exists?(definition[:name])
-        end
+        model = definition[:model].safe_constantize
+        return unless model
+        return unless connection.table_exists?(definition[:name])
 
-        stats = screenshot || fetch_counts(definition[:model].constantize, definition)
-        limit = screenshot ? screenshot[:limit] : @config.max_table_records&.[](definition[:name])
+        stats = fetch_counts(model, definition)
+        limit = @config.max_table_records&.[](definition[:name])
         count = stats[:count]
         percent = limit.to_i.positive? ? ((count.to_f / limit) * 100).round(1) : nil
         severity = fill_severity(percent, count, limit)
@@ -223,7 +187,7 @@ module RailsPulse
           newest_at: stats[:newest_at],
           recent_count: stats[:recent_count],
           runway_label: runway_label(count, limit, stats[:recent_count]),
-          bytes: screenshot ? screenshot[:bytes] : table_bytes(definition[:name]),
+          bytes: measured_table_bytes(definition[:name]),
           history_label: history_label(stats[:oldest_at], stats[:newest_at])
         }
       rescue => error
@@ -351,6 +315,12 @@ module RailsPulse
         row[key] || row[key.to_s] || row[key.to_s.upcase] || row[key.to_sym]
       end
 
+      def measured_table_bytes(table_name)
+        return table_bytes(table_name) unless @cached_sizes
+
+        self.class.cached_table_bytes(table_name) { table_bytes(table_name) }
+      end
+
       def table_bytes(table_name)
         adapter = connection.adapter_name.downcase