rails_pulse 0.4.2 → 0.5.0.pre.2

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

@@ -2,10 +2,12 @@ import { Controller } from "@hotwired/stimulus"
 
 export default class extends Controller {
   static values = {
-    type: String,        // "bar", "line", "area", "sparkline"
-    data: Object,        // Chart data
-    options: Object,     // ECharts configuration
-    theme: String        // ECharts theme
+    type: String,            // "bar", "line", "area", "sparkline"
+    data: Object,            // Chart data
+    options: Object,         // ECharts configuration
+    theme: String,           // ECharts theme
+    timezone: String,        // IANA zone summaries were bucketed in (e.g. "Etc/UTC")
+    timezoneLabel: String    // Human label for the same zone (e.g. "UTC")
   }
 
   connect() {
@@ -401,6 +403,46 @@ export default class extends Controller {
     return this.getSafeFormatter(cleanString)
   }
 
+  // Formats in the aggregation zone, not the browser's — SummaryJob fixes a
+  // day's boundary at write time, so browser-zone display can flip the date.
+  formatDailyDate(date, extraOptions = {}) {
+    const timeZone = this.timezoneValue || undefined
+    return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', timeZone, ...extraOptions })
+  }
+
+  // "Mon D, HH:MM" — the hourly-granularity counterpart to formatDailyDate.
+  formatDailyDateTime(date) {
+    const timeZone = this.timezoneValue || undefined
+    return date.toLocaleString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false, timeZone })
+  }
+
+  // "HH:MM" only, same zone as the above.
+  formatHourMinute(date) {
+    const timeZone = this.timezoneValue || undefined
+    return date.toLocaleString('en-US', { hour: '2-digit', minute: '2-digit', hour12: false, timeZone })
+  }
+
+  // Year comparison in the same zone as the label it decorates, so a point
+  // near New Year is not tagged with a year the aggregation zone has not
+  // reached yet (or has already left).
+  isCurrentYear(date) {
+    const options = { year: 'numeric', timeZone: this.timezoneValue || undefined }
+    return date.toLocaleDateString('en-US', options) === new Date().toLocaleDateString('en-US', options)
+  }
+
+  // Hourly vs. daily comes from the formatter key Ruby chose, not ECharts'
+  // generated axisValueLabel (unreliable for some axis-pointer/series combos).
+  isHourlyAxis() {
+    return this.optionsValue?.xAxis?.axisLabel?.formatter === "time"
+  }
+
+  // Appends " (Zone)" to a tooltip's date/time string when a zone label is
+  // available, so a hover always says which zone the point is in.
+  withZoneSuffix(dateString) {
+    const zone = this.timezoneLabelValue || ''
+    return zone ? `${dateString} (${zone})` : dateString
+  }
+
   /**
    * Returns a safe formatter function based on the formatter string.
    * This prevents arbitrary code execution by using a whitelist approach.
@@ -455,7 +497,7 @@ export default class extends Controller {
             return value.toString()
           }
 
-          return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+          return this.formatDailyDate(date)
         }
         return value
       },
@@ -463,17 +505,14 @@ export default class extends Controller {
       // Time only (formatted as "HH:00" to match Rails Pulse formatters)
       'time': (value) => {
         if (typeof value === 'number' || typeof value === 'string') {
-          // Convert to number if string
           const numValue = typeof value === 'string' ? parseInt(value) : value
           const date = new Date(numValue)
 
-          const hours = date.getHours()
-          if (isNaN(hours)) {
+          if (isNaN(date.getTime())) {
             return value.toString()
           }
 
-          const minutes = date.getMinutes()
-          return hours.toString().padStart(2, '0') + ':' + minutes.toString().padStart(2, '0')
+          return this.formatHourMinute(date)
         }
         return value
       },
@@ -501,9 +540,7 @@ export default class extends Controller {
 
         const data = params[0]
         const date = new Date(data.axisValue)
-        const hours = date.getHours().toString().padStart(2, '0')
-        const minutes = date.getMinutes().toString().padStart(2, '0')
-        const dateString = `${hours}:${minutes}`
+        const dateString = this.withZoneSuffix(this.formatHourMinute(date))
         const value = parseInt(data.data)
 
         return `${dateString} <br /> ${data.marker} ${value} ms`
@@ -515,7 +552,7 @@ export default class extends Controller {
 
         const data = params[0]
         const date = new Date(data.axisValue)
-        const dateString = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+        const dateString = this.withZoneSuffix(this.formatDailyDate(date))
         const value = parseInt(data.data)
 
         return `${dateString} <br /> ${data.marker} ${value} ms`
@@ -527,9 +564,7 @@ export default class extends Controller {
 
         const data = params[0]
         const date = new Date(data.axisValue)
-        const hours = date.getHours().toString().padStart(2, '0')
-        const minutes = date.getMinutes().toString().padStart(2, '0')
-        const dateString = `${hours}:${minutes}`
+        const dateString = this.withZoneSuffix(this.formatHourMinute(date))
 
         return `${dateString} <br /> ${data.marker} ${data.data}`
       },
@@ -540,7 +575,7 @@ export default class extends Controller {
 
         const data = params[0]
         const date = new Date(data.axisValue)
-        const dateString = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+        const dateString = this.withZoneSuffix(this.formatDailyDate(date))
 
         return `${dateString} <br /> ${data.marker} ${data.data}`
       },
@@ -558,13 +593,14 @@ export default class extends Controller {
           const timestamp = Number(axisValue)
           const date = new Date(timestamp)
           if (!isNaN(date.getTime())) {
-            dateString = date.toLocaleDateString('en-US', {
-              month: 'short',
-              day: 'numeric',
-              year: date.getFullYear() !== new Date().getFullYear() ? 'numeric' : undefined
+            dateString = this.formatDailyDate(date, {
+              year: this.isCurrentYear(date) ? undefined : 'numeric'
             })
           }
         }
+        // Category axis sends an already-formatted label (e.g. "Apr 28")
+        // instead of a timestamp — still needs the suffix below.
+        dateString = this.withZoneSuffix(dateString)
 
         // Build tooltip HTML with all series
         let html = `${dateString}<br/>`
@@ -587,7 +623,7 @@ export default class extends Controller {
         if (typeof numValue === 'number' && !isNaN(numValue) && numValue > 1000000000000) {
           const date = new Date(numValue)
           if (!isNaN(date.getTime())) {
-            return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+            return this.formatDailyDate(date)
           }
         }
 
@@ -599,23 +635,26 @@ export default class extends Controller {
       'tooltip_with_timestamp': (params) => {
         if (!Array.isArray(params) || params.length === 0) return ''
 
-        // axisValueLabel is the pre-formatted axis label (e.g. "Apr/28" or "04:00")
-        // axisValue is the raw value — a ms timestamp for time axis, category string otherwise
+        // axisValue is the raw value — a ms timestamp for time axis, an
+        // already-formatted category string (e.g. "Apr 28") otherwise
         const axisValue = params[0].axisValue
         const ts = Number(axisValue)
         let dateString
 
         if (!isNaN(ts) && ts > 1000000000000) {
           const date = new Date(ts)
-          // Show time component if sub-day granularity (axis label is HH:mm style)
-          const axisLabel = params[0].axisValueLabel || ''
-          const isHourly = /^\d{2}:\d{2}$/.test(axisLabel)
-          dateString = isHourly
-            ? date.toLocaleString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false })
-            : date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+          // Sub-day granularity comes from the formatter Ruby chose for this
+          // chart, not from ECharts' own generated axisValueLabel (unreliable
+          // for some axis-pointer/series combinations — see isHourlyAxis()).
+          dateString = this.isHourlyAxis() ? this.formatDailyDateTime(date) : this.formatDailyDate(date)
         } else {
+          // Category axis (daily/weekly/monthly charts send a plain,
+          // already-formatted label like "Apr 28" instead of an epoch
+          // timestamp) — still needs the zone suffix, same as the time-axis
+          // branch above, or daily-grouped charts silently lose it.
           dateString = axisValue
         }
+        dateString = this.withZoneSuffix(dateString)
 
         // Build tooltip HTML with all series
         let html = `${dateString}<br/>`
@@ -643,12 +682,13 @@ export default class extends Controller {
         if (typeof numValue === 'number' && !isNaN(numValue) && numValue > 1000000000000) {
           const date = new Date(numValue)
           if (!isNaN(date.getTime())) {
-            const hours = date.getHours().toString().padStart(2, '0')
-            const minutes = date.getMinutes().toString().padStart(2, '0')
-            axisValue = `${hours}:${minutes}`
+            axisValue = this.formatHourMinute(date)
           }
         }
-        // If it's already a formatted string (like "Apr 5"), leave it as-is
+        // Either the hour just computed above, or an already-formatted daily
+        // label (like "Apr 5") — both need the suffix, or daily sparklines
+        // silently lose it.
+        axisValue = this.withZoneSuffix(axisValue)
 
         // Show marker, series name, and value (e.g., "● P95: 150")
         return `${axisValue}<br/>${data.marker} ${seriesName}: ${value}`
@@ -669,11 +709,10 @@ export default class extends Controller {
         if (typeof numValue === 'number' && !isNaN(numValue) && numValue > 1000000000000) {
           const date = new Date(numValue)
           if (!isNaN(date.getTime())) {
-            const hours = date.getHours().toString().padStart(2, '0')
-            const minutes = date.getMinutes().toString().padStart(2, '0')
-            axisValue = `${hours}:${minutes}`
+            axisValue = this.formatHourMinute(date)
           }
         }
+        axisValue = this.withZoneSuffix(axisValue)
 
         return `${axisValue}<br/>${data.marker} ${seriesName}: ${value}`
       },
@@ -688,14 +727,12 @@ export default class extends Controller {
 
         if (!isNaN(ts) && ts > 1000000000000) {
           const date = new Date(ts)
-          const axisLabel = params[0].axisValueLabel || ''
-          const isHourly = /^\d{2}:\d{2}$/.test(axisLabel)
-          dateString = isHourly
-            ? date.toLocaleString('en-US', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false })
-            : date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+          dateString = this.isHourlyAxis() ? this.formatDailyDateTime(date) : this.formatDailyDate(date)
         } else {
+          // Category axis (daily/weekly/monthly) — see tooltip_with_timestamp.
           dateString = axisValue
         }
+        dateString = this.withZoneSuffix(dateString)
 
         let html = `${dateString}<br/>`
         params.forEach(param => {

data/app/jobs/rails_pulse/backfill_summaries_job.rb

@@ -6,8 +6,10 @@ module RailsPulse
     # @param period_types [Array<String>] Period types to backfill (default: ["hour", "day"])
     # @return [nil]
     def perform(start_date, end_date, period_types = [ "hour", "day" ])
-      start_date = start_date.to_datetime
-      end_date = end_date.to_datetime
+      # A Date or date string means midnight in the aggregation time zone, so
+      # backfilled periods land on the boundaries the scheduled job writes.
+      start_date = start_date.in_time_zone
+      end_date = end_date.in_time_zone
 
       period_types.each do |period_type|
         backfill_period(period_type, start_date, end_date)

data/app/jobs/rails_pulse/cloud_health_job.rb

@@ -0,0 +1,11 @@
+module RailsPulse
+  # Sends the health update for the minute just ended to Rails Pulse Cloud,
+  # deployments recorded since the last run, and any buffered batches whose
+  # retry is due. Schedule it every minute alongside SummaryJob. Does nothing
+  # unless config.cloud is set.
+  class CloudHealthJob < ApplicationJob
+    def perform
+      Cloud::Sync.new.minutely
+    end
+  end
+end

data/app/jobs/rails_pulse/cloud_sync_job.rb

@@ -0,0 +1,11 @@
+module RailsPulse
+  # Sends newly summarized hours, changed exception groups and deployments to
+  # Rails Pulse Cloud. SummaryJob enqueues it once its summaries are written,
+  # so it needs no schedule of its own. Does nothing unless config.cloud is
+  # set.
+  class CloudSyncJob < ApplicationJob
+    def perform
+      Cloud::Sync.new.hourly
+    end
+  end
+end

data/app/jobs/rails_pulse/summary_job.rb

@@ -19,6 +19,8 @@ module RailsPulse
         # Check if we should run monthly summary (first day of month)
         process_monthly_summary((target_hour.to_date - 1.month).beginning_of_month) if first_of_month?(target_hour)
       end
+
+      enqueue_cloud_sync
     rescue StandardError => e
       log_error(e)
       raise
@@ -26,6 +28,17 @@ module RailsPulse
 
     private
 
+    # Cloud receives an hour only once it is summarized, so the sync follows
+    # this job rather than running on a schedule of its own. A queue that
+    # refuses the job must not fail the summaries already written.
+    def enqueue_cloud_sync
+      return unless RailsPulse.configuration.cloud.enabled?
+
+      CloudSyncJob.perform_later
+    rescue StandardError => e
+      RailsPulse.logger.error "Could not enqueue the Rails Pulse Cloud sync: #{e.class} - #{e.message}"
+    end
+
     def midnight?(time)
       time.hour == 0
     end

data/app/models/concerns/rails_pulse/has_metadata.rb

@@ -0,0 +1,15 @@
+module RailsPulse
+  module HasMetadata
+    extend ActiveSupport::Concern
+
+    # metadata can be valid JSON that isn't an object (an array, a scalar)
+    def metadata_hash
+      return {} if metadata.blank?
+
+      parsed = JSON.parse(metadata)
+      parsed.is_a?(Hash) ? parsed : {}
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/app/models/concerns/rails_pulse/taggable.rb

@@ -5,25 +5,18 @@ module RailsPulse
     # Tag validation constants
     TAG_NAME_REGEX = /\A[a-z0-9_-]+\z/i
     MAX_TAG_LENGTH = 50
-    # Escape character for LIKE patterns over the serialized tags column.
-    # Never appears in a valid tag name, and needs no quoting on any adapter.
-    LIKE_ESCAPE = "!".freeze
-
     included do
       # Callbacks
       before_save :ensure_tags_is_array
 
-      # Scopes with table name qualification to avoid ambiguity.
-      # LIKE patterns are sanitized so `_`/`%` in a tag are matched literally.
-      # The ESCAPE clause is explicit because SQLite has no default escape
-      # character — without it `my\_tag` matches a literal backslash there
-      # and the filter silently matches nothing. `!` is used rather than `\`
-      # because MySQL and PostgreSQL disagree on how to quote a backslash.
+      # Scopes with table name qualification to avoid ambiguity. Tags are
+      # matched against the serialized column, so the quoted tag name is
+      # escaped by LikePattern and paired with its ESCAPE clause.
       scope :with_tag, ->(tag) {
-        where("#{table_name}.tags LIKE ? ESCAPE '!'", "%\"#{sanitize_sql_like(tag.to_s, LIKE_ESCAPE)}\"%")
+        where("#{table_name}.tags LIKE ? #{RailsPulse::LikePattern::CLAUSE}", "%\"#{RailsPulse::LikePattern.escape(tag)}\"%")
       }
       scope :without_tag, ->(tag) {
-        where.not("#{table_name}.tags LIKE ? ESCAPE '!'", "%\"#{sanitize_sql_like(tag.to_s, LIKE_ESCAPE)}\"%")
+        where.not("#{table_name}.tags LIKE ? #{RailsPulse::LikePattern::CLAUSE}", "%\"#{RailsPulse::LikePattern.escape(tag)}\"%")
       }
       scope :with_tags, -> { where("#{table_name}.tags IS NOT NULL AND #{table_name}.tags != '[]'") }
     end

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

@@ -3,14 +3,21 @@ require "active_support/number_helper"
 module RailsPulse
   module Cards
     class Base
+      def initialize(window: nil, subject: nil, period: 7, period_type: "day", disabled_tags: [], show_non_tagged: true)
+        @window = window
+        @subject = subject
+        @period = period
+        @period_type = period_type
+        @disabled_tags = disabled_tags
+        @show_non_tagged = show_non_tagged
+      end
+
       private
 
-      # nil unless the caller passed both start_time and end_time, so the
-      # "trailing @period days/hours" fallback below still applies by default.
+      # nil unless the caller passed a window, 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)
+        @window
       end
 
       def now
@@ -74,14 +81,16 @@ module RailsPulse
       end
 
       def subject_id
-        # Subclasses can override to provide @job.id, @query.id, @route.id
-        instance_variable_get(:@job)&.id ||
-          instance_variable_get(:@query)&.id ||
-          instance_variable_get(:@route)&.id
+        @subject&.id
       end
 
-      def quote(time)
-        RailsPulse::Summary.connection.quote(time)
+      # A SELECT fragment comparing against the card's window, with the
+      # bounds bound as values (:current_start, :range_start) rather than
+      # interpolated into the SQL string.
+      def window_sql(fragment)
+        Arel.sql(
+          RailsPulse::Summary.sanitize_sql_array([ fragment, { current_start: current_window_start, range_start: range_start } ])
+        )
       end
 
       # Enhanced sparkline generation (support hour and day)

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

@@ -1,18 +1,14 @@
 module RailsPulse
   module Charts
     class Base
-      def initialize(ransack_query:, period_type: nil, subject: nil, start_time: nil, end_time: nil, start_duration: nil, disabled_tags: [], show_non_tagged: true, **options)
+      def initialize(ransack_query:, period_type: nil, subject: nil, window: nil, start_duration: nil, disabled_tags: [], show_non_tagged: true)
         @ransack_query = ransack_query
         @period_type = period_type
         @subject = subject
-        @start_time = start_time
-        @end_time = end_time
+        @window = window
         @start_duration = start_duration
         @disabled_tags = disabled_tags
         @show_non_tagged = show_non_tagged
-
-        # Support legacy parameter names (job, query, route)
-        @subject ||= options[:job] || options[:query] || options[:route]
       end
 
       private
@@ -28,23 +24,14 @@ module RailsPulse
           .then { |q| @subject ? q.where(summarizable_id: @subject.id) : q }
       end
 
-      # Common helper for time step calculation
-      def time_step
-        @period_type.to_s == "hour" ? 3600 : 86400
-      end
-
       # Abstract method - must be implemented by subclasses
       def summarizable_type
         raise NotImplementedError, "#{self.class} must implement summarizable_type"
       end
 
-      # Common helper for padding missing data points with zeros
-      def pad_data_with_zeros(raw_data, start_time, end_time, step)
-        {}.tap do |padded|
-          (start_time.to_i..end_time.to_i).step(step) do |timestamp|
-            padded[timestamp] = raw_data[timestamp] || 0
-          end
-        end
+      # Every bucket in the window, with zero where there is no data.
+      def pad_data_with_zeros(raw_data)
+        @window.bucket_timestamps(@period_type).index_with { |timestamp| raw_data[timestamp] || 0 }
       end
     end
   end

data/app/models/rails_pulse/charts/percentile_chart_base.rb

@@ -1,12 +1,11 @@
 module RailsPulse
   module Charts
     class PercentileChartBase
-      def initialize(ransack_query:, period_type: nil, subject: nil, start_time: nil, end_time: nil, start_duration: nil, disabled_tags: [], show_non_tagged: true)
+      def initialize(ransack_query:, period_type: nil, subject: nil, window: nil, start_duration: nil, disabled_tags: [], show_non_tagged: true)
         @ransack_query = ransack_query
         @period_type = period_type
         @subject = subject
-        @start_time = start_time
-        @end_time = end_time
+        @window = window
         @start_duration = start_duration
         @disabled_tags = disabled_tags
         @show_non_tagged = show_non_tagged
@@ -48,9 +47,8 @@ module RailsPulse
         end
 
         # Convert to final values (weighted averages) and pad missing data
-        step = @period_type.to_s == "hour" ? 3600 : 86400
         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/cleanup_run.rb

@@ -0,0 +1,32 @@
+module RailsPulse
+  # One CleanupService run, stored as an Event of kind cleanup_run: `value`
+  # is the rows it deleted, `outcome` completed or failed, and `metadata` the
+  # per-table counts and any stages that failed. rails_pulse:status reads the
+  # latest to say whether cleanup is running at all; nothing else depends on
+  # these rows, so event retention prunes them like any other kind.
+  class CleanupRun
+    KIND = "cleanup_run".freeze
+    SUBJECT = "cleanup".freeze
+
+    class << self
+      def events
+        RailsPulse::Event.of_kind(KIND)
+      end
+
+      def record!(stats:, failed_stages: [], ran_at: Time.current)
+        RailsPulse::Event.create!(
+          kind:        KIND,
+          subject:     SUBJECT,
+          outcome:     failed_stages.any? ? "failed" : "completed",
+          value:       stats[:total_deleted].to_i,
+          occurred_at: ran_at,
+          metadata:    { time_based: stats[:time_based], count_based: stats[:count_based], failed_stages: failed_stages }.to_json
+        )
+      end
+
+      def latest
+        events.recent.first
+      end
+    end
+  end
+end

data/app/models/rails_pulse/cloud/buffered_batch.rb

@@ -0,0 +1,55 @@
+require "zlib"
+
+module RailsPulse
+  module Cloud
+    # A batch waiting to be sent to Rails Pulse Cloud, stored gzipped. It
+    # keeps its batch_id across retries, so Cloud recognises a resend. The
+    # buffer holds at most MAX_AGE or MAX_BYTES of batches, dropping the
+    # oldest first, so an outage cannot grow it without bound.
+    class BufferedBatch < RailsPulse::ApplicationRecord
+      self.table_name = "rails_pulse_cloud_batches"
+
+      MAX_AGE = 7.days
+      MAX_BYTES = 50.megabytes
+
+      validates :batch_id, :payload, :byte_size, :item_count, :next_attempt_at, presence: true
+
+      scope :due, ->(now = Time.current) { where(next_attempt_at: ..now).order(:created_at, :id) }
+
+      def self.ransackable_attributes(_auth_object = nil)
+        %w[batch_id byte_size item_count attempts next_attempt_at created_at]
+      end
+
+      def self.ransackable_associations(_auth_object = nil)
+        []
+      end
+
+      def self.enqueue!(batch, now: Time.current)
+        payload = Zlib.gzip(batch.to_json)
+        create!(batch_id: batch.batch_id, payload: payload, byte_size: payload.bytesize, item_count: batch.items.size,
+                next_attempt_at: now)
+      end
+
+      # Drops batches past MAX_AGE, then the oldest until the rest fit in
+      # MAX_BYTES. Returns how many were dropped.
+      def self.prune!(now = Time.current)
+        dropped = where(created_at: ...(now - MAX_AGE)).delete_all
+        total = sum(:byte_size)
+        return dropped if total <= MAX_BYTES
+
+        order(:created_at, :id).pluck(:id, :byte_size).each do |id, size|
+          break if total <= MAX_BYTES
+
+          dropped += where(id: id).delete_all
+          total -= size
+        end
+        dropped
+      end
+
+      # The stored batch as a hash with string keys.
+      def contents
+        JSON.parse(Zlib.gunzip(payload))
+      end
+    end
+  end
+end

data/app/models/rails_pulse/cloud/installation.rb

@@ -0,0 +1,55 @@
+module RailsPulse
+  module Cloud
+    # The one row naming this Rails Pulse database to Rails Pulse Cloud, and
+    # where its sync has got to. Hosts that share the database share the row,
+    # so their data is counted once; hosts with separate databases are
+    # separate installations, and Cloud adds them together.
+    class Installation < RailsPulse::ApplicationRecord
+      self.table_name = "rails_pulse_cloud_installations"
+
+      validates :installation_id, presence: true
+
+      def self.ransackable_attributes(_auth_object = nil)
+        %w[installation_id last_success_at last_error_at paused_until created_at]
+      end
+
+      def self.ransackable_associations(_auth_object = nil)
+        []
+      end
+
+      # The row, created with a new installation ID the first time it is
+      # asked for. A second process creating it at the same moment loses on
+      # the unique index and reads the winner's.
+      def self.current
+        first || create!(installation_id: SecureRandom.uuid)
+      rescue ActiveRecord::RecordNotUnique
+        first!
+      end
+
+      # The row if one exists, without creating it.
+      def self.existing
+        first
+      rescue ActiveRecord::ActiveRecordError
+        nil
+      end
+
+      def paused?(now = Time.current)
+        paused_until.present? && paused_until > now
+      end
+
+      def record_success!(deprecated_on: nil, now: Time.current)
+        update!(last_success_at: now, last_error: nil, last_error_at: nil, paused_until: nil, pause_reason: nil,
+                contract_deprecated_on: deprecated_on)
+      end
+
+      def record_error!(message, now: Time.current)
+        update!(last_error: message.to_s.truncate(2_000), last_error_at: now)
+      end
+
+      def pause!(until_time, reason, now: Time.current)
+        update!(paused_until: until_time, pause_reason: reason.to_s.truncate(2_000),
+                last_error: reason.to_s.truncate(2_000), last_error_at: now)
+      end
+    end
+  end
+end

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

@@ -2,13 +2,12 @@ module RailsPulse
   module Dashboard
     module Charts
       class ResponseTimePercentiles
-        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
@@ -169,10 +168,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