rails_pulse 0.5.0.pre.1 → 0.5.0

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

@@ -9,6 +9,30 @@ module RailsPulse
 
           [ @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,11 +4,13 @@ module RailsPulse
       include Concerns::ThresholdConstants
       include Concerns::TimeRangeHelper
 
-      def initialize(disabled_tags: [], show_non_tagged: true, period: 7, window: 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
+        @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
@@ -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,7 @@ 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
@@ -152,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,14 +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, window: 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
+        @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
@@ -40,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
@@ -48,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",
@@ -70,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 << {
@@ -88,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",
@@ -142,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
@@ -199,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 << {
@@ -217,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
@@ -261,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)
 
@@ -319,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,8 +8,10 @@ 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 + writer_drop_items
+        @pressure_items ||= summary_staleness_items + sub_hour_retention_items + writer_drop_items
       end
 
       # Dropped requests get their own Tracking badge, not this one
@@ -47,43 +49,7 @@ module RailsPulse
         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
@@ -108,7 +74,7 @@ module RailsPulse
         } ]
       end
 
-      # Signal D — the background writer is discarding requests
+      # Signal C — the background writer is discarding requests
       def writer_drop_items
         return [] unless RailsPulse::Event.table_available?
 
@@ -148,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>"
@@ -161,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

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

@@ -34,7 +34,7 @@ module RailsPulse
           name: :rails_pulse_summaries,
           model: "RailsPulse::Summary",
           label: "Summaries",
-          description: "Hourly and daily aggregates used by charts. Hourly rows older than 2 days are cleaned up",
+          description: "Hourly and daily aggregates used by charts. Hourly rows are cleaned up after 7 days by default (hourly_summary_retention)",
           time_column: :period_start
         },
         {
@@ -78,42 +78,43 @@ module RailsPulse
           label: "Events",
           description: "What Pulse noticed: writer heartbeats every minute, pruned after a day; any other kind is kept for event_retention_period",
           time_column: :occurred_at
+        },
+        {
+          name: :rails_pulse_cloud_batches,
+          model: "RailsPulse::Cloud::BufferedBatch",
+          label: "Cloud buffer",
+          description: "Batches waiting to be sent to Rails Pulse Cloud. Held for at most 7 days or 50 MB",
+          time_column: :created_at
         }
       ].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
+      # The Storage page counts every row exactly: one unindexed COUNT/MIN/MAX
+      # scan per table, which takes tens of seconds on large installs. The
+      # dashboard only shows headline counts and fill bars, so with
+      # estimated: true it reads the catalog's row estimates instead
+      # (pg_class.reltuples, information_schema TABLE_ROWS). SQLite keeps no
+      # such estimate, and dbstat walks the whole file, so there the dashboard
+      # measures no tables at all.
+      def initialize(estimated: false, storage_pressure: nil)
+        @config = RailsPulse.configuration
+        @pressure = storage_pressure || StoragePressure.new
+        @estimated = estimated
+      end
 
-        def reset_size_cache!
-          @size_cache_mutex.synchronize { @size_cache.clear }
-        end
+      def estimated?
+        @estimated
       end
 
-      def initialize(cached_sizes: false)
-        @config = RailsPulse.configuration
-        @pressure = StoragePressure.new
-        @cached_sizes = cached_sizes
+      def counts_available?
+        !(@estimated && sqlite?)
       end
 
       def tables
-        @tables ||= TABLE_CATALOG.filter_map { |definition| build_table(definition) }
+        @tables ||= if counts_available?
+          with_current_mysql_statistics { TABLE_CATALOG.filter_map { |definition| build_table(definition) } }
+        else
+          []
+        end
       end
 
       def pressure_items
@@ -198,12 +199,37 @@ module RailsPulse
         RailsPulse::ApplicationRecord.connection
       end
 
+      # MySQL 8 caches information_schema's TABLE_ROWS, DATA_LENGTH and
+      # INDEX_LENGTH for information_schema_stats_expiry seconds, a day by
+      # default, so a table that grew after its first read reports its old
+      # size. An expiry of 0 reads current statistics; a SET_VAR hint does
+      # not reach information_schema, so it is set on the session and put
+      # back afterwards because the connection returns to the pool. MariaDB
+      # has no such variable and does not cache, so the block runs as is.
+      def with_current_mysql_statistics
+        previous = session_statistics_expiry
+        return yield if previous.nil?
+
+        connection.execute("SET SESSION information_schema_stats_expiry = 0")
+        yield
+      ensure
+        connection.execute("SET SESSION information_schema_stats_expiry = #{previous.to_i}") unless previous.nil?
+      end
+
+      def session_statistics_expiry
+        return unless mysql?
+
+        connection.select_value("SELECT @@SESSION.information_schema_stats_expiry")
+      rescue ActiveRecord::StatementInvalid
+        nil
+      end
+
       def build_table(definition)
         model = definition[:model].safe_constantize
         return unless model
         return unless connection.table_exists?(definition[:name])
 
-        stats = fetch_counts(model, definition)
+        stats = measured_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
@@ -223,7 +249,7 @@ module RailsPulse
           newest_at: stats[:newest_at],
           recent_count: stats[:recent_count],
           runway_label: runway_label(count, limit, stats[:recent_count]),
-          bytes: measured_table_bytes(definition[:name]),
+          bytes: table_bytes(definition[:name]),
           history_label: history_label(stats[:oldest_at], stats[:newest_at])
         }
       rescue => error
@@ -247,6 +273,33 @@ module RailsPulse
         }
       end
 
+      def measured_counts(model, definition)
+        return fetch_counts(model, definition) unless @estimated
+
+        { count: estimated_count(definition[:name]), oldest_at: nil, newest_at: nil, recent_count: 0 }
+      end
+
+      def estimated_count(table_name)
+        if connection.adapter_name.downcase.include?("postgres")
+          estimate = connection.select_value(
+            "SELECT reltuples::bigint FROM pg_class WHERE oid = to_regclass(#{connection.quote(table_name.to_s)})"
+          ).to_i
+          # -1 until the table's first ANALYZE; autovacuum runs one after
+          # about 50 inserts, so a table without an estimate is small enough
+          # to count.
+          estimate.negative? ? connection.select_value("SELECT COUNT(*) FROM #{connection.quote_table_name(table_name)}").to_i : estimate
+        else
+          connection.select_value(
+            RailsPulse::ApplicationRecord.sanitize_sql_array([ <<~SQL, table_name.to_s ])
+              SELECT TABLE_ROWS
+              FROM information_schema.TABLES
+              WHERE TABLE_SCHEMA = DATABASE()
+                AND TABLE_NAME = ?
+            SQL
+          ).to_i
+        end
+      end
+
       def fetch_counts(model, definition)
         quoted_table = connection.quote_table_name(definition[:name])
         time_column = definition[:time_column]
@@ -351,12 +404,6 @@ 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
 
@@ -364,7 +411,7 @@ module RailsPulse
           connection.select_value(
             "SELECT pg_total_relation_size(#{connection.quote(table_name.to_s)})"
           ).to_i
-        elsif adapter.include?("mysql")
+        elsif mysql?
           connection.select_value(
             RailsPulse::ApplicationRecord.sanitize_sql_array([ <<~SQL, table_name.to_s ])
               SELECT DATA_LENGTH + INDEX_LENGTH
@@ -410,11 +457,19 @@ module RailsPulse
         nil
       end
 
+      def mysql?
+        connection.adapter_name.downcase.match?(/mysql|trilogy/)
+      end
+
+      def sqlite?
+        connection.adapter_name.downcase.include?("sqlite")
+      end
+
       def adapter_label
         name = connection.adapter_name
         case name.downcase
         when /postgres/ then "PostgreSQL"
-        when /mysql/ then "MySQL"
+        when /mysql|trilogy/ then "MySQL"
         when /sqlite/ then "SQLite"
         else name
         end
@@ -443,7 +498,7 @@ module RailsPulse
           "File size of the dedicated Rails Pulse SQLite database."
         elsif adapter.include?("postgres")
           "PostgreSQL relation size including indexes (pg_total_relation_size)."
-        elsif adapter.include?("mysql")
+        elsif mysql?
           "MySQL data + index length from information_schema."
         end
       end

data/app/models/rails_pulse/event.rb

@@ -3,8 +3,9 @@ module RailsPulse
   # outcome or sample, tagged by `kind`; `subject` names what it is about,
   # `value` carries its number and `metadata` the kind-specific detail as JSON.
   #
-  # The one kind written today is writer_heartbeat (see WriterHeartbeat). The
-  # table is generic so a new kind needs no migration. Decision 0019.
+  # Two kinds are written today: writer_heartbeat (see WriterHeartbeat) and
+  # cleanup_run (see CleanupRun). The table is generic so a new kind needs no
+  # migration. Decision 0019.
   #
   # CleanupService deletes rows older than config.event_retention_period,
   # except kinds listed in config.event_retention_exempt_kinds (rows a writer

data/app/models/rails_pulse/exceptions/charts/occurrence_volume.rb

@@ -41,10 +41,8 @@ module RailsPulse
         # answer "zero" rather than "no data" — leaving the gap unfilled would
         # draw a chart that skips quiet days and misrepresents the trend.
         def pad_with_zeros(raw)
-          step = @period_type.to_s == "hour" ? 3600 : 86_400
-
           {}.tap do |padded|
-            (@window.start_time.to_i..@window.end_time.to_i).step(step) do |timestamp|
+            @window.bucket_timestamps(@period_type).each do |timestamp|
               padded[timestamp] = raw[timestamp] || 0
             end
           end

data/app/models/rails_pulse/jobs/charts/duration.rb

@@ -31,9 +31,8 @@ module RailsPulse
           end
 
           # Convert to final values (weighted averages) and pad missing data
-          step = time_step
           daily_data = {}
-          (@window.start_time.to_i..@window.end_time.to_i).step(step) do |timestamp|
+          @window.bucket_timestamps(@period_type).each do |timestamp|
             if raw_data[timestamp]
               count = raw_data[timestamp][:total_count]
               daily_data[timestamp] = {