rails_pulse 0.4.2 → 0.5.0.pre.2

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
         },
         {
@@ -71,42 +71,50 @@ module RailsPulse
           label: "Deployments",
           description: "Deploy markers shown on charts",
           time_column: :started_at
+        },
+        {
+          name: :rails_pulse_events,
+          model: "RailsPulse::Event",
+          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
@@ -137,6 +145,35 @@ module RailsPulse
         }
       end
 
+      # Built from live_processes/dropped_by_process rather than
+      # WriterHeartbeat.summary, which would recompute both internally.
+      def tracking
+        @tracking ||= begin
+          live = RailsPulse::WriterHeartbeat.live_processes
+          dropped_by_process = RailsPulse::WriterHeartbeat.dropped_by_process(window: 1.hour)
+          processes = live.map do |process|
+            {
+              label: process.process_label,
+              queue_depth: process.queue_depth,
+              queue_size: process.queue_size,
+              dropped_last_hour: dropped_by_process.fetch(process.process_label, 0),
+              last_seen_at: process.sampled_at
+            }
+          end
+
+          {
+            processes:       processes,
+            live_count:      processes.size,
+            queue_depth:     live.sum(&:queue_depth),
+            queue_size:      live.map(&:queue_size).max || 0,
+            dropped:         dropped_by_process.values.sum,
+            last_sampled_at: RailsPulse::WriterHeartbeat.events.maximum(:occurred_at)
+          }
+        end
+      rescue ActiveRecord::ActiveRecordError
+        { processes: [], live_count: 0, queue_depth: 0, queue_size: 0, dropped: 0, last_sampled_at: nil }
+      end
+
       def dashboard_tables
         capped = tables.select { |table| table[:limit] }
         return tables.first(4) if capped.empty?
@@ -162,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
@@ -187,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
@@ -211,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]
@@ -315,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
 
@@ -328,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
@@ -374,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
@@ -407,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/deployment.rb

@@ -1,5 +1,7 @@
 module RailsPulse
   class Deployment < RailsPulse::ApplicationRecord
+    include HasMetadata
+
     self.table_name = "rails_pulse_deployments"
 
     # The create endpoint is reachable with a CI token, so every field a
@@ -52,13 +54,6 @@ module RailsPulse
       finished_at - started_at
     end
 
-    def metadata_hash
-      return {} if metadata.blank?
-      JSON.parse(metadata)
-    rescue JSON::ParserError
-      {}
-    end
-
     def to_chart_marker
       { timestamp: started_at.to_i * 1000, revision: revision, started_at: started_at.iso8601 }
     end

data/app/models/rails_pulse/event.rb

@@ -0,0 +1,41 @@
+module RailsPulse
+  # What Rails Pulse noticed, as opposed to what it measured. One row per
+  # outcome or sample, tagged by `kind`; `subject` names what it is about,
+  # `value` carries its number and `metadata` the kind-specific detail as JSON.
+  #
+  # 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
+  # updates in place). Writer heartbeats are pruned after a day by the writer
+  # itself.
+  class Event < RailsPulse::ApplicationRecord
+    include HasMetadata
+
+    self.table_name = "rails_pulse_events"
+
+    validates :kind, :outcome, :occurred_at, presence: true
+
+    scope :of_kind,     ->(*kinds) { where(kind: kinds.flatten.map(&:to_s)) }
+    scope :for_subject, ->(subject) { where(subject: subject) }
+    scope :since,       ->(time) { where(occurred_at: time..) }
+    scope :recent,      -> { order(occurred_at: :desc) }
+
+    def self.ransackable_attributes(_auth_object = nil)
+      %w[kind subject outcome value occurred_at message created_at updated_at]
+    end
+
+    def self.ransackable_associations(_auth_object = nil)
+      []
+    end
+
+    # table_exists?, rescued — for an upgrader who hasn't migrated yet
+    def self.table_available?
+      table_exists?
+    rescue ActiveRecord::ActiveRecordError
+      false
+    end
+  end
+end

data/app/models/rails_pulse/exception_occurrence.rb

@@ -21,7 +21,7 @@ module RailsPulse
     end
 
     def to_breadcrumb
-      occurred_at.getlocal.strftime("%b %d, %Y %l:%M %p")
+      occurred_at.strftime("%b %d, %Y %l:%M %p")
     end
   end
 end

data/app/models/rails_pulse/exceptions/cards/exception_rate.rb

@@ -16,10 +16,7 @@ module RailsPulse
         PER = 1_000
 
         def initialize(disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day")
-          @disabled_tags   = disabled_tags
-          @show_non_tagged = show_non_tagged
-          @period          = period
-          @period_type     = period_type
+          super
         end
 
         def to_metric_card
@@ -63,8 +60,8 @@ module RailsPulse
             .where(period_type: @period_type, period_start: range_start..now)
             .select(
               "SUM(rails_pulse_summaries.count) AS total_count",
-              "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS current_count",
-              "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(range_start)} AND rails_pulse_summaries.period_start < #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS previous_count"
+              window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :current_start THEN rails_pulse_summaries.count ELSE 0 END) AS current_count"),
+              window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :range_start AND rails_pulse_summaries.period_start < :current_start THEN rails_pulse_summaries.count ELSE 0 END) AS previous_count")
             )
             .take
 

data/app/models/rails_pulse/exceptions/cards/open_groups.rb

@@ -9,10 +9,7 @@ module RailsPulse
       # you about the other.
       class OpenGroups < RailsPulse::Cards::Base
         def initialize(disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day")
-          @disabled_tags   = disabled_tags
-          @show_non_tagged = show_non_tagged
-          @period          = period
-          @period_type     = period_type
+          super
         end
 
         def to_metric_card

data/app/models/rails_pulse/exceptions/cards/total_occurrences.rb

@@ -11,10 +11,7 @@ module RailsPulse
         SUMMARIZABLE_TYPE = "RailsPulse::ExceptionGroup".freeze
 
         def initialize(disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day")
-          @disabled_tags   = disabled_tags
-          @show_non_tagged = show_non_tagged
-          @period          = period
-          @period_type     = period_type
+          super
         end
 
         def to_metric_card
@@ -24,8 +21,8 @@ module RailsPulse
 
           metrics = base_query.select(
             "SUM(rails_pulse_summaries.count) AS total_count",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS current_count",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(range_start)} AND rails_pulse_summaries.period_start < #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS previous_count"
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :current_start THEN rails_pulse_summaries.count ELSE 0 END) AS current_count"),
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :range_start AND rails_pulse_summaries.period_start < :current_start THEN rails_pulse_summaries.count ELSE 0 END) AS previous_count")
           ).take
 
           total    = metrics&.total_count.to_i

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

@@ -8,16 +8,15 @@ module RailsPulse
       # silently flattens toward zero the further back you look. Summaries are
       # retained at day granularity indefinitely.
       class OccurrenceVolume
-        def initialize(start_time:, end_time:, period_type: "day")
-          @start_time  = start_time
-          @end_time    = end_time
+        def initialize(window:, period_type: "day")
+          @window      = window
           @period_type = period_type
         end
 
         def to_chart_data
           totals = RailsPulse::Summary
             .overall_exceptions
-            .where(period_type: @period_type, period_start: @start_time..@end_time)
+            .where(period_type: @period_type, period_start: @window.start_time..@window.end_time)
             .group(:period_start)
             .sum(:count)
 
@@ -42,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|
-            (@start_time.to_i..@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/job_run.rb

@@ -40,7 +40,7 @@ module RailsPulse
     after_commit :apply_to_job_caches, on: %i[create update], if: :finalized?
 
     def to_breadcrumb
-      occurred_at.getlocal.strftime("%b %d, %Y %l:%M %p")
+      occurred_at.strftime("%b %d, %Y %l:%M %p")
     end
 
     def all_tags

data/app/models/rails_pulse/jobs/cards/failure_rate.rb

@@ -2,14 +2,8 @@ module RailsPulse
   module Jobs
     module Cards
       class FailureRate < RailsPulse::Cards::Base
-        def initialize(job: nil, disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day", start_time: nil, end_time: nil)
-          @job = job
-          @disabled_tags = disabled_tags
-          @show_non_tagged = show_non_tagged
-          @period = period
-          @period_type = period_type
-          @start_time = start_time
-          @end_time = end_time
+        def initialize(job: nil, period: 14, **kwargs)
+          super(subject: job, period: period, **kwargs)
         end
 
         def to_metric_card
@@ -20,15 +14,15 @@ module RailsPulse
               period_type: @period_type,
               period_start: range_start..now
             )
-          base_query = base_query.where(summarizable_id: @job.id) if @job
+          base_query = base_query.where(summarizable_id: @subject.id) if @subject
 
           metrics = base_query.select(
             "SUM(rails_pulse_summaries.count) AS total_count",
             "SUM(rails_pulse_summaries.error_count) AS total_errors",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS current_count",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(current_window_start)} THEN rails_pulse_summaries.error_count ELSE 0 END) AS current_errors",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(range_start)} AND rails_pulse_summaries.period_start < #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS previous_count",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(range_start)} AND rails_pulse_summaries.period_start < #{quote(current_window_start)} THEN rails_pulse_summaries.error_count ELSE 0 END) AS previous_errors"
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :current_start THEN rails_pulse_summaries.count ELSE 0 END) AS current_count"),
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :current_start THEN rails_pulse_summaries.error_count ELSE 0 END) AS current_errors"),
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :range_start AND rails_pulse_summaries.period_start < :current_start THEN rails_pulse_summaries.count ELSE 0 END) AS previous_count"),
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :range_start AND rails_pulse_summaries.period_start < :current_start THEN rails_pulse_summaries.error_count ELSE 0 END) AS previous_errors")
           ).take
 
           total_runs = metrics&.total_count.to_i
@@ -52,7 +46,7 @@ module RailsPulse
               period_type: @period_type,
               period_start: current_window_start..now
             )
-          sparkline_query = sparkline_query.where(summarizable_id: @job.id) if @job
+          sparkline_query = sparkline_query.where(summarizable_id: @subject.id) if @subject
 
           grouped_errors = bucket_by_period(sparkline_query) { |relation| relation.sum("rails_pulse_summaries.error_count") }
           grouped_counts = bucket_by_period(sparkline_query) { |relation| relation.sum("rails_pulse_summaries.count") }

data/app/models/rails_pulse/jobs/cards/p95_duration.rb

@@ -2,14 +2,8 @@ module RailsPulse
   module Jobs
     module Cards
       class P95Duration < RailsPulse::Cards::Base
-        def initialize(job: nil, disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day", start_time: nil, end_time: nil)
-          @job = job
-          @disabled_tags = disabled_tags
-          @show_non_tagged = show_non_tagged
-          @period = period
-          @period_type = period_type
-          @start_time = start_time
-          @end_time = end_time
+        def initialize(job: nil, period: 14, **kwargs)
+          super(subject: job, period: period, **kwargs)
         end
 
         def to_metric_card
@@ -20,15 +14,15 @@ module RailsPulse
               period_type: @period_type,
               period_start: range_start..now
             )
-          base_query = base_query.where(summarizable_id: @job.id) if @job
+          base_query = base_query.where(summarizable_id: @subject.id) if @subject
 
           metrics = base_query.select(
             "SUM(rails_pulse_summaries.p95_duration * rails_pulse_summaries.count) AS total_weighted_p95",
             "SUM(rails_pulse_summaries.count) AS total_runs",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(current_window_start)} THEN rails_pulse_summaries.p95_duration * rails_pulse_summaries.count ELSE 0 END) AS current_weighted_p95",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS current_runs",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(range_start)} AND rails_pulse_summaries.period_start < #{quote(current_window_start)} THEN rails_pulse_summaries.p95_duration * rails_pulse_summaries.count ELSE 0 END) AS previous_weighted_p95",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(range_start)} AND rails_pulse_summaries.period_start < #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS previous_runs"
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :current_start THEN rails_pulse_summaries.p95_duration * rails_pulse_summaries.count ELSE 0 END) AS current_weighted_p95"),
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :current_start THEN rails_pulse_summaries.count ELSE 0 END) AS current_runs"),
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :range_start AND rails_pulse_summaries.period_start < :current_start THEN rails_pulse_summaries.p95_duration * rails_pulse_summaries.count ELSE 0 END) AS previous_weighted_p95"),
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :range_start AND rails_pulse_summaries.period_start < :current_start THEN rails_pulse_summaries.count ELSE 0 END) AS previous_runs")
           ).take
 
           total_runs = metrics&.total_runs.to_i
@@ -42,7 +36,7 @@ module RailsPulse
           current_p95 = weighted_average(current_weighted_p95, current_runs)
           previous_p95 = weighted_average(previous_weighted_p95, previous_runs)
 
-          baseline = baseline_trend_for(@job, metric: :p95)
+          baseline = baseline_trend_for(@subject, metric: :p95)
 
           if baseline
             trend_icon, trend_amount, trend_caption = baseline

data/app/models/rails_pulse/jobs/cards/total_runs.rb

@@ -2,14 +2,8 @@ module RailsPulse
   module Jobs
     module Cards
       class TotalRuns < RailsPulse::Cards::Base
-        def initialize(job: nil, disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day", start_time: nil, end_time: nil)
-          @job = job
-          @disabled_tags = disabled_tags
-          @show_non_tagged = show_non_tagged
-          @period = period
-          @period_type = period_type
-          @start_time = start_time
-          @end_time = end_time
+        def initialize(job: nil, period: 14, **kwargs)
+          super(subject: job, period: period, **kwargs)
         end
 
         def to_metric_card
@@ -20,12 +14,12 @@ module RailsPulse
               period_type: @period_type,
               period_start: range_start..now
             )
-          base_query = base_query.where(summarizable_id: @job.id) if @job
+          base_query = base_query.where(summarizable_id: @subject.id) if @subject
 
           metrics = base_query.select(
             "SUM(rails_pulse_summaries.count) AS total_count",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS current_count",
-            "SUM(CASE WHEN rails_pulse_summaries.period_start >= #{quote(range_start)} AND rails_pulse_summaries.period_start < #{quote(current_window_start)} THEN rails_pulse_summaries.count ELSE 0 END) AS previous_count"
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :current_start THEN rails_pulse_summaries.count ELSE 0 END) AS current_count"),
+            window_sql("SUM(CASE WHEN rails_pulse_summaries.period_start >= :range_start AND rails_pulse_summaries.period_start < :current_start THEN rails_pulse_summaries.count ELSE 0 END) AS previous_count")
           ).take
 
           total_runs = metrics&.total_count.to_i

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 = {}
-          (@start_time.to_i..@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] = {

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

@@ -21,7 +21,7 @@ module RailsPulse
           end
 
           # Pad missing data with zeros using base class helper
-          daily_data = pad_data_with_zeros(raw_data, @start_time, @end_time, time_step)
+          daily_data = pad_data_with_zeros(raw_data)
 
           # Build series data as [timestamp_ms, value] pairs for ECharts time axis
           series = [ {

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

@@ -23,9 +23,8 @@ module RailsPulse
           end
 
           # Pad missing data with zeros
-          step = time_step
           daily_data = {}
-          (@start_time.to_i..@end_time.to_i).step(step) do |timestamp|
+          @window.bucket_timestamps(@period_type).each do |timestamp|
             daily_data[timestamp] = raw_data[timestamp] || nil
           end
 

data/app/models/rails_pulse/like_pattern.rb

@@ -0,0 +1,35 @@
+module RailsPulse
+  # Builds LIKE patterns whose `_`, `%` and escape characters match literally.
+  #
+  # Every pattern built here must be used with CLAUSE appended to the LIKE
+  # expression. SQLite has no default escape character, so `foo!_bar` without an
+  # explicit ESCAPE matches a literal `!` while the `_` still wildcards, and the
+  # comparison silently matches nothing. `!` is the escape character rather than
+  # `\` because MySQL and PostgreSQL disagree on how a backslash is quoted.
+  module LikePattern
+    ESCAPE_CHARACTER = "!".freeze
+
+    # Interpolated directly into SQL strings, so it must stay a literal.
+    CLAUSE = "ESCAPE '#{ESCAPE_CHARACTER}'".freeze
+
+    module_function
+
+    # @param value [#to_s] user-supplied text to match anywhere in a column
+    # @return [String] escaped pattern wrapped in leading and trailing wildcards
+    def containing(value)
+      "%#{escape(value)}%"
+    end
+
+    # @param value [#to_s] user-supplied text to match at the start of a column
+    # @return [String] escaped pattern followed by a trailing wildcard
+    def starting_with(value)
+      "#{escape(value)}%"
+    end
+
+    # @param value [#to_s] user-supplied text
+    # @return [String] the text with LIKE metacharacters escaped
+    def escape(value)
+      ActiveRecord::Base.sanitize_sql_like(value.to_s, ESCAPE_CHARACTER)
+    end
+  end
+end