rails_pulse 0.4.2 → 0.5.0.pre.1

data/app/models/rails_pulse/routes/cards/error_rates.rb

@@ -2,14 +2,8 @@ module RailsPulse
   module Routes
     module Cards
       class ErrorRates < RailsPulse::Cards::Base
-        def initialize(route: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
-          @route = route
-          @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(route: nil, **kwargs)
+          super(subject: route, **kwargs)
         end
 
         def to_metric_card
@@ -20,8 +14,8 @@ module RailsPulse
             "SUM(error_count) AS total_errors",
             "SUM(status_4xx) AS total_4xx",
             "SUM(count) AS total_requests",
-            "SUM(CASE WHEN period_start >= #{quote(current_window_start)} THEN error_count + status_4xx ELSE 0 END) AS current_total_errors",
-            "SUM(CASE WHEN period_start >= #{quote(range_start)} AND period_start < #{quote(current_window_start)} THEN error_count + status_4xx ELSE 0 END) AS previous_total_errors"
+            window_sql("SUM(CASE WHEN period_start >= :current_start THEN error_count + status_4xx ELSE 0 END) AS current_total_errors"),
+            window_sql("SUM(CASE WHEN period_start >= :range_start AND period_start < :current_start THEN error_count + status_4xx ELSE 0 END) AS previous_total_errors")
           ).take
 
           total_errors = metrics.total_errors || 0
@@ -35,7 +29,7 @@ module RailsPulse
           server_rate = has_data ? (total_errors.to_f / total_requests * 100).round(2) : 0
           client_rate = has_data ? (total_4xx.to_f / total_requests * 100).round(2) : 0
 
-          baseline = baseline_trend_for(@route, metric: :error_rate)
+          baseline = baseline_trend_for(@subject, metric: :error_rate)
 
           if baseline
             trend_icon, trend_amount, trend_caption = baseline
@@ -72,10 +66,6 @@ module RailsPulse
 
         private
 
-        def subject_id
-          @route&.id
-        end
-
         def sparkline_from_error_rates(errors_by_period, client_errors_by_period, counts_by_period)
           if @period_type == "hour"
             sparkline_hours.each_with_object({}) do |current_time, result|

data/app/models/rails_pulse/routes/cards/percentile_response_times.rb

@@ -2,14 +2,8 @@ module RailsPulse
   module Routes
     module Cards
       class PercentileResponseTimes < RailsPulse::Cards::Base
-        def initialize(route: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
-          @route = route
-          @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(route: nil, **kwargs)
+          super(subject: route, **kwargs)
         end
 
         def to_metric_card
@@ -18,8 +12,8 @@ module RailsPulse
 
           metrics = base_query.select(
             "SUM(p95_duration * count) / NULLIF(SUM(count), 0) AS overall_p95",
-            "SUM(CASE WHEN period_start >= #{quote(current_window_start)} THEN p95_duration * count ELSE 0 END) / NULLIF(SUM(CASE WHEN period_start >= #{quote(current_window_start)} THEN count ELSE 0 END), 0) AS current_p95",
-            "SUM(CASE WHEN period_start >= #{quote(range_start)} AND period_start < #{quote(current_window_start)} THEN p95_duration * count ELSE 0 END) / NULLIF(SUM(CASE WHEN period_start >= #{quote(range_start)} AND period_start < #{quote(current_window_start)} THEN count ELSE 0 END), 0) AS previous_p95",
+            window_sql("SUM(CASE WHEN period_start >= :current_start THEN p95_duration * count ELSE 0 END) / NULLIF(SUM(CASE WHEN period_start >= :current_start THEN count ELSE 0 END), 0) AS current_p95"),
+            window_sql("SUM(CASE WHEN period_start >= :range_start AND period_start < :current_start THEN p95_duration * count ELSE 0 END) / NULLIF(SUM(CASE WHEN period_start >= :range_start AND period_start < :current_start THEN count ELSE 0 END), 0) AS previous_p95"),
             "SUM(count) AS total_count"
           ).take
 
@@ -32,7 +26,7 @@ module RailsPulse
 
           # Prefer a comparison against this route's own history; fall back to
           # period-over-period on the index, where there is no single subject.
-          baseline = baseline_trend_for(@route, metric: :p95)
+          baseline = baseline_trend_for(@subject, metric: :p95)
 
           if baseline
             trend_icon, trend_amount, trend_caption = baseline
@@ -69,12 +63,6 @@ module RailsPulse
             help_text: "The 95th percentile response time — 95% of requests are faster than this. Weighted by request volume across all routes. A rising P95 indicates increasing slowness affecting your users."
           }
         end
-
-        private
-
-        def subject_id
-          @route&.id
-        end
       end
     end
   end

data/app/models/rails_pulse/routes/cards/request_count_totals.rb

@@ -2,14 +2,8 @@ module RailsPulse
   module Routes
     module Cards
       class RequestCountTotals < RailsPulse::Cards::Base
-        def initialize(route: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
-          @route = route
-          @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(route: nil, **kwargs)
+          super(subject: route, **kwargs)
         end
 
         def to_metric_card
@@ -18,8 +12,8 @@ module RailsPulse
 
           metrics = base_query.select(
             "SUM(count) AS total_count",
-            "SUM(CASE WHEN period_start >= #{quote(current_window_start)} THEN count ELSE 0 END) AS current_count",
-            "SUM(CASE WHEN period_start >= #{quote(range_start)} AND period_start < #{quote(current_window_start)} THEN count ELSE 0 END) AS previous_count"
+            window_sql("SUM(CASE WHEN period_start >= :current_start THEN count ELSE 0 END) AS current_count"),
+            window_sql("SUM(CASE WHEN period_start >= :range_start AND period_start < :current_start THEN count ELSE 0 END) AS previous_count")
           ).take
 
           # Calculate metrics from single query result
@@ -42,7 +36,7 @@ module RailsPulse
               period_type: @period_type,
               period_start: current_window_start..now
             )
-          sparkline_query = sparkline_query.where(summarizable_id: @route.id) if @route
+          sparkline_query = sparkline_query.where(summarizable_id: @subject.id) if @subject
 
           grouped_data = bucket_by_period(sparkline_query) { |relation| relation.sum(:count) }
 
@@ -83,12 +77,6 @@ module RailsPulse
             help_text: "Total HTTP requests served over the last 14 days, expressed as an average rate. Use this to understand traffic patterns and capacity planning needs."
           }
         end
-
-        private
-
-        def subject_id
-          @route&.id
-        end
       end
     end
   end

data/app/models/rails_pulse/routes/charts/error_rate.rb

@@ -30,7 +30,7 @@ module RailsPulse
           # Pad missing data with defaults
           default_value = { error_rate: nil, client_error_rate: nil }
           daily_data = {}
-          (@start_time.to_i..@end_time.to_i).step(time_step) do |timestamp|
+          (@window.start_time.to_i..@window.end_time.to_i).step(time_step) do |timestamp|
             daily_data[timestamp] = raw_data[timestamp] || default_value
           end
 

data/app/models/rails_pulse/routes/charts/request_volume.rb

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

data/app/models/rails_pulse/summary.rb

@@ -171,7 +171,11 @@ module RailsPulse
     end
 
     class << self
+      # A Date is read as midnight in Time.zone, the aggregation zone, so
+      # boundaries are always times: Date#end_of_week is the last day itself,
+      # and a period ending there would drop that whole day.
       def calculate_period_end(period_type, start_time)
+        start_time = start_time.in_time_zone if start_time.is_a?(Date)
         case period_type
         when "hour"  then start_time.end_of_hour
         when "day"   then start_time.end_of_day
@@ -181,6 +185,7 @@ module RailsPulse
       end
 
       def normalize_period_start(period_type, time)
+        time = time.in_time_zone if time.is_a?(Date)
         case period_type
         when "hour"  then time.beginning_of_hour
         when "day"   then time.beginning_of_day

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

@@ -4,10 +4,9 @@ module RailsPulse
       WEIGHTED_P95 = "SUM(rails_pulse_summaries.p95_duration * rails_pulse_summaries.count) / NULLIF(SUM(rails_pulse_summaries.count), 0)"
       WEIGHTED_P99 = "SUM(rails_pulse_summaries.p99_duration * rails_pulse_summaries.count) / NULLIF(SUM(rails_pulse_summaries.count), 0)"
 
-      def initialize(ransack_query:, period_type: nil, start_time:, params:, disabled_tags: [], show_non_tagged: true)
+      def initialize(ransack_query:, period_type: nil, params:, disabled_tags: [], show_non_tagged: true)
         @ransack_query = ransack_query
         @period_type = period_type
-        @start_time = start_time
         @params = params
         @disabled_tags = disabled_tags
         @show_non_tagged = show_non_tagged
@@ -41,11 +40,11 @@ module RailsPulse
       def apply_tag_filters(query)
         actual_disabled_tags = @disabled_tags.reject { |tag| tag == "non_tagged" }
 
-        # Explicit ESCAPE: SQLite has no default escape character, so without
-        # it an underscore in a tag is never matched literally there.
         actual_disabled_tags.each do |tag|
-          sanitized_tag = ActiveRecord::Base.sanitize_sql_like(tag.to_s, RailsPulse::Taggable::LIKE_ESCAPE)
-          query = query.where.not("#{model_table}.tags LIKE ? ESCAPE '!'", "%#{sanitized_tag}%")
+          query = query.where.not(
+            "#{model_table}.tags LIKE ? #{RailsPulse::LikePattern::CLAUSE}",
+            RailsPulse::LikePattern.containing(tag)
+          )
         end
 
         unless @show_non_tagged

data/app/models/rails_pulse/time_range.rb

@@ -0,0 +1,309 @@
+module RailsPulse
+  # Resolves the dashboard's time range, chart-zoom/table window, and
+  # duration-threshold filter from request params and session state, in one
+  # pass. Returns a single frozen Result so every caller — controllers,
+  # views, cards, charts — reads the same object instead of each re-deriving
+  # its own answer.
+  #
+  # Priority order for the chart/page window (highest first):
+  #   1. Page-specific preset from the dropdown (params[:q][:period_start_range])
+  #   2. Page-specific custom range from the picker (params[:q][:custom_date_range])
+  #   3. Chart zoom / drill-down params (params[:q][:occurred_at_gteq/_lt])
+  #   4. Time range selector preference (session[:time_range_preference])
+  #   5. Global filters (session[:global_filters]["start_time"/"end_time"])
+  #   6. Default (default_key)
+  #
+  # Every input is parsed in Time.zone, matching how Summary rows are
+  # bucketed — parsing a custom-range string in any other zone would
+  # misinterpret the intended instant whenever that zone differs from
+  # Time.zone, silently resolving to the wrong window.
+  class TimeRange
+    Result = Struct.new(
+      :window, :table_window, :period_type, :selected_time_range,
+      :zoom_start, :zoom_end, :start_duration, :selected_response_range,
+      keyword_init: true
+    )
+
+    PRESET_START = {
+      "last_24_hours" => -> { 1.day.ago },
+      "last_7_days"   => -> { 1.week.ago },
+      "last_14_days"  => -> { 2.weeks.ago },
+      "last_30_days"  => -> { 1.month.ago }
+    }.freeze
+
+    # Human-readable label for the zone daily/weekly/monthly summaries are
+    # bucketed in and custom ranges are rounded in (see class comment above)
+    # — the host app's config.time_zone, not the browser's zone. "UTC" or,
+    # e.g., "Eastern Time (US & Canada) (UTC-04:00)".
+    #
+    # This reads the Time.zone of the current dashboard request and assumes
+    # it is the zone SummaryJob ran under. That holds when both use
+    # config.time_zone (decision 0020). A host that overrides Time.zone per
+    # request for the dashboard as well would see a label that names the
+    # display zone while the daily buckets were still cut in the job's zone.
+    def self.aggregation_zone_label
+      return "UTC" if utc_zone?
+      "#{Time.zone.name} (UTC#{Time.zone.now.formatted_offset})"
+    end
+
+    # Compact form of aggregation_zone_label for chart headings and tooltip
+    # suffixes, where the full name would crowd out the data: "UTC", the
+    # zone's abbreviation when it has an alphabetic one ("EDT"), otherwise
+    # the offset ("UTC+05:45").
+    def self.aggregation_zone_short_label
+      return "UTC" if utc_zone?
+      abbreviation = Time.zone.now.zone
+      abbreviation.match?(/\A[A-Z]{2,5}\z/) ? abbreviation : "UTC#{Time.zone.now.formatted_offset}"
+    end
+
+    # IANA identifier for the same zone, for the chart JS (Intl.DateTimeFormat)
+    # to render daily labels in the zone summaries were actually bucketed in
+    # instead of the browser's zone.
+    def self.aggregation_zone_iana
+      Time.zone.tzinfo.name
+    end
+
+    def self.utc_zone?
+      Time.zone.utc_offset.zero? && Time.zone.now.zone == "UTC"
+    end
+    private_class_method :utc_zone?
+
+    def self.resolve(params:, session:, default_key: :last_24_hours, duration_range_type: :route)
+      new(params: params, session: session, default_key: default_key, duration_range_type: duration_range_type).resolve
+    end
+
+    def initialize(params:, session:, default_key:, duration_range_type:)
+      @params = params
+      @session = session
+      @default_key = default_key
+      @duration_range_type = duration_range_type
+    end
+
+    def resolve
+      start_time, end_time, selected_time_range = resolve_window
+      start_time, end_time, time_diff_hours = normalize(start_time, end_time)
+      period_type = time_diff_hours <= 25 ? "hour" : "day"
+
+      zoom_start, zoom_end, table_start, table_end = resolve_zoom(start_time.to_i, end_time.to_i)
+      start_duration, selected_response_range = resolve_duration
+
+      Result.new(
+        window: RailsPulse::TimeWindow.new(start_time, end_time),
+        table_window: RailsPulse::TimeWindow.new(table_start, table_end),
+        period_type: period_type,
+        selected_time_range: selected_time_range.to_s,
+        zoom_start: zoom_start,
+        zoom_end: zoom_end,
+        start_duration: start_duration,
+        selected_response_range: selected_response_range
+      ).freeze
+    end
+
+    private
+
+    attr_reader :params, :session, :default_key, :duration_range_type
+
+    # -- Window resolution (priorities 1-6) ----------------------------------
+
+    def resolve_window
+      from_page_preset || from_page_custom_range || from_chart_zoom ||
+        from_session_custom || from_session_preset || from_global_filters ||
+        default_window
+    end
+
+    def default_window
+      [ preset_start(default_key), Time.zone.now, default_key ]
+    end
+
+    def preset_start(key)
+      (PRESET_START[key.to_s] || PRESET_START["last_24_hours"]).call
+    end
+
+    # Priority 1: page-specific preset from the dropdown.
+    def from_page_preset
+      range = ransack_params[:period_start_range]
+      return nil unless range.present? && range.to_sym != :custom
+
+      [ preset_start(range), Time.zone.now, range ]
+    end
+
+    # Priority 2: page-specific custom datetime range from the picker (only
+    # when period_start_range is explicitly "custom").
+    def from_page_custom_range
+      return nil unless ransack_params[:period_start_range].present? &&
+        ransack_params[:period_start_range].to_sym == :custom &&
+        ransack_params[:custom_date_range].present? &&
+        ransack_params[:custom_date_range].include?(" to ")
+
+      dates = ransack_params[:custom_date_range].split(" to ")
+      custom_start = parse_time_param(dates[0].strip)
+      custom_end = parse_time_param(dates[1].strip)
+      return nil unless custom_start && custom_end
+
+      [ custom_start, custom_end, :custom ]
+    end
+
+    # Priority 3: custom time range from chart zoom.
+    def from_chart_zoom
+      return nil unless ransack_params[:occurred_at_gteq].present? && ransack_params[:occurred_at_lt].present?
+
+      zoom_start = parse_time_param(ransack_params[:occurred_at_gteq])
+      zoom_end = parse_time_param(ransack_params[:occurred_at_lt])
+      return nil unless zoom_start && zoom_end
+
+      [ zoom_start, zoom_end, :custom ]
+    end
+
+    # Priority 4a: custom range from the time range selector (session).
+    def from_session_custom
+      preference = session_time_range_preference
+      return nil unless RailsPulse::TimeRangePreference.custom?(preference)
+
+      start_time = parse_time_param(preference["start_time"]) || preset_start(default_key)
+      end_time = parse_time_param(preference["end_time"]) || Time.zone.now
+      [ start_time, end_time, :custom ]
+    end
+
+    # Priority 4b: preset from the time range selector (session).
+    def from_session_preset
+      preference = session_time_range_preference
+      return nil unless preference.is_a?(String) && preference.present?
+
+      [ preset_start(preference), Time.zone.now, preference.to_sym ]
+    end
+
+    # Priority 5: global filters (session).
+    def from_global_filters
+      filters = session_global_filters
+      return nil unless filters["start_time"].present? || filters["end_time"].present?
+
+      start_time = parse_time_param(filters["start_time"]) || preset_start(default_key)
+      end_time = parse_time_param(filters["end_time"]) || Time.zone.now
+      [ start_time, end_time, :custom ]
+    end
+
+    def ransack_params
+      q = params[:q]
+      q.respond_to?(:permit) ? q : ActionController::Parameters.new({})
+    end
+
+    def session_time_range_preference
+      RailsPulse::TimeRangePreference.normalize(session[:time_range_preference])
+    end
+
+    def session_global_filters
+      filters = session[:global_filters]
+      filters.is_a?(Hash) ? filters : {}
+    end
+
+    # Returns nil for anything that does not parse, so a hand-edited or stale
+    # value falls back to the default range instead of raising.
+    def parse_time_param(param)
+      case param
+      when Time, DateTime
+        param.in_time_zone
+      when String
+        return nil if param.blank?
+
+        Time.zone.parse(param)
+      when Numeric
+        Time.zone.at(param)
+      else
+        nil
+      end
+    rescue ArgumentError, TypeError, RangeError
+      nil
+    end
+
+    # Rounds to hour or day boundaries in Time.zone (summaries are always
+    # bucketed there) and returns the span in hours (float) alongside.
+    def normalize(start_time, end_time)
+      start_time = start_time.in_time_zone
+      end_time = end_time.in_time_zone
+      time_diff_hours = (end_time.to_i - start_time.to_i) / 3600.0
+
+      if time_diff_hours <= 25
+        [ start_time.beginning_of_hour, end_time.end_of_hour, time_diff_hours ]
+      else
+        [ start_time.beginning_of_day, end_time.end_of_day, time_diff_hours ]
+      end
+    end
+
+    # -- Zoom / table window --------------------------------------------------
+
+    def resolve_zoom(main_start, main_end)
+      selected_column_time = params[:selected_column_time]
+      zoom_start = params.delete(:zoom_start_time)
+      zoom_end = params.delete(:zoom_end_time)
+
+      if selected_column_time
+        table_start, table_end = normalize_column_time(selected_column_time.to_i, main_start, main_end)
+        # Column selection has highest precedence for the table only; the
+        # chart keeps showing the full range, so zoom_start/zoom_end are
+        # returned as extracted (not normalized) rather than derived here.
+        return [ zoom_start, zoom_end, table_start, table_end ]
+      end
+
+      zoom_start, zoom_end = normalize_zoom_times(zoom_start.to_i, zoom_end.to_i) if zoom_start && zoom_end
+
+      table_start = zoom_start || main_start
+      table_end = zoom_end || main_end
+
+      [ zoom_start, zoom_end, table_start, table_end ]
+    end
+
+    # column_time_ms is JS milliseconds; period boundary is based on the
+    # overall page range (main_start/main_end), same as the chart.
+    def normalize_column_time(column_time_ms, main_start, main_end)
+      column_time_seconds = column_time_ms / 1000
+      time_diff_hours = (main_end - main_start) / 3600.0
+      column_time_obj = Time.zone&.at(column_time_seconds) || Time.at(column_time_seconds)
+
+      if time_diff_hours <= 25
+        [ column_time_obj.beginning_of_hour.to_i, column_time_obj.end_of_hour.to_i ]
+      else
+        [ column_time_obj.beginning_of_day.to_i, column_time_obj.end_of_day.to_i ]
+      end
+    end
+
+    # start_ms/end_ms are JS milliseconds; period boundary is based on the
+    # zoomed span itself.
+    def normalize_zoom_times(start_ms, end_ms)
+      start_seconds = start_ms / 1000
+      end_seconds = end_ms / 1000
+      time_diff_hours = (end_seconds - start_seconds) / 3600.0
+      start_obj = Time.zone&.at(start_seconds) || Time.at(start_seconds)
+      end_obj = Time.zone&.at(end_seconds) || Time.at(end_seconds)
+
+      if time_diff_hours <= 25
+        [ start_obj.beginning_of_hour.to_i, end_obj.end_of_hour.to_i ]
+      else
+        [ start_obj.beginning_of_day.to_i, end_obj.end_of_day.to_i ]
+      end
+    end
+
+    # -- Duration threshold -----------------------------------------------------
+
+    def resolve_duration
+      thresholds = RailsPulse.configuration.public_send("#{duration_range_type}_thresholds")
+      duration_param = ransack_params[:avg_duration] || ransack_params[:duration] || ransack_params[:duration_gteq]
+
+      if duration_param.present?
+        [ threshold_for(thresholds, duration_param), duration_param ]
+      elsif (global_threshold = session_global_filters["performance_threshold"]).present?
+        [ threshold_for(thresholds, global_threshold), global_threshold.to_sym ]
+      else
+        [ 0, :all ]
+      end
+    end
+
+    def threshold_for(thresholds, key)
+      case key.to_sym
+      when :slow then thresholds[:slow]
+      when :very_slow then thresholds[:very_slow]
+      when :critical then thresholds[:critical]
+      else 0
+      end
+    end
+  end
+end

data/app/models/rails_pulse/writer_heartbeat.rb

@@ -0,0 +1,86 @@
+module RailsPulse
+  # The background writer's once-a-minute sample, stored as an Event of kind
+  # writer_heartbeat: `subject` is "host:pid", `value` the requests dropped
+  # since the previous sample, and `metadata` the queue depth, its configured
+  # capacity and the lifetime drop count. Stats are otherwise per process, so
+  # with eight Puma workers the dashboard could only ever see the one that
+  # happened to serve it; these rows let it, the Storage page and
+  # rails_pulse:status add every live writer up.
+  class WriterHeartbeat
+    KIND = "writer_heartbeat".freeze
+    # A writer that has not reported for this long is treated as gone.
+    LIVE_WINDOW = 3.minutes
+    RETENTION = 24.hours
+
+    Sample = Struct.new(:hostname, :pid, :queue_size, :queue_depth, :dropped_total, :sampled_at, keyword_init: true) do
+      def process_label
+        "#{hostname}:#{pid}"
+      end
+    end
+
+    class << self
+      def events
+        RailsPulse::Event.of_kind(KIND)
+      end
+
+      def record!(hostname:, pid:, queue_size:, queue_depth:, dropped:, dropped_total:, sampled_at: Time.current)
+        RailsPulse::Event.insert_all([ {
+          kind:        KIND,
+          subject:     "#{hostname}:#{pid}",
+          outcome:     "sampled",
+          value:       dropped,
+          occurred_at: sampled_at,
+          metadata:    { hostname: hostname, pid: pid, queue_size: queue_size, queue_depth: queue_depth, dropped_total: dropped_total }.to_json,
+          created_at:  sampled_at,
+          updated_at:  sampled_at
+        } ])
+      end
+
+      def prune!
+        events.where(occurred_at: ...RETENTION.ago).delete_all
+      end
+
+      # The latest sample from each writer that reported inside LIVE_WINDOW,
+      # newest first. A handful of rows per process, reduced in Ruby.
+      def live_processes
+        events.since(LIVE_WINDOW.ago).recent.to_a.uniq(&:subject).map { |event| sample_from(event) }
+      end
+
+      # { "host:pid" => requests dropped inside `window` }
+      def dropped_by_process(window: 1.hour)
+        events.since(window.ago).group(:subject).sum(:value).transform_values(&:to_i)
+      end
+
+      # What the dashboard, Storage page and status task show:
+      #   processes        live writers
+      #   queue_depth      requests waiting across them, from each one's latest sample
+      #   queue_size       the largest configured capacity among them
+      #   dropped          requests dropped inside `window`, across every process
+      #   last_sampled_at  most recent heartbeat, nil when there is none
+      def summary(window: 1.hour)
+        processes = live_processes
+        {
+          processes:       processes.size,
+          queue_depth:     processes.sum(&:queue_depth),
+          queue_size:      processes.map(&:queue_size).max || 0,
+          dropped:         events.since(window.ago).sum(:value).to_i,
+          last_sampled_at: events.maximum(:occurred_at)
+        }
+      end
+
+      private
+
+      def sample_from(event)
+        meta = event.metadata_hash
+        Sample.new(
+          hostname:      meta["hostname"],
+          pid:           meta["pid"],
+          queue_size:    meta["queue_size"].to_i,
+          queue_depth:   meta["queue_depth"].to_i,
+          dropped_total: meta["dropped_total"].to_i,
+          sampled_at:    event.occurred_at
+        )
+      end
+    end
+  end
+end

data/app/serializers/rails_pulse/api/v1/deployment_serializer.rb

@@ -0,0 +1,20 @@
+module RailsPulse
+  module Api
+    module V1
+      class DeploymentSerializer
+        def self.serialize(deployment)
+          {
+            id:               deployment.id,
+            revision:         deployment.revision,
+            short_revision:   deployment.short_revision,
+            started_at:       deployment.started_at,
+            finished_at:      deployment.finished_at,
+            duration_seconds: deployment.duration&.round(1),
+            in_progress:      deployment.in_progress?,
+            metadata:         deployment.metadata_hash
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/rails_pulse/api/v1/exception_group_serializer.rb

@@ -0,0 +1,23 @@
+module RailsPulse
+  module Api
+    module V1
+      class ExceptionGroupSerializer
+        def self.serialize(group)
+          {
+            id:               group.id,
+            fingerprint:      group.fingerprint,
+            exception_class:  group.exception_class,
+            location:         group.location,
+            message:          group.message,
+            status:           group.status,
+            occurrence_count: group.occurrence_count,
+            first_seen_at:    group.first_seen_at,
+            last_seen_at:     group.last_seen_at,
+            resolved_at:      group.resolved_at,
+            preserve:         group.preserve
+          }
+        end
+      end
+    end
+  end
+end

data/app/serializers/rails_pulse/api/v1/exception_occurrence_serializer.rb

@@ -0,0 +1,22 @@
+module RailsPulse
+  module Api
+    module V1
+      class ExceptionOccurrenceSerializer
+        def self.serialize(occurrence)
+          {
+            id:             occurrence.id,
+            exception_class: occurrence.exception_class,
+            message:        occurrence.message,
+            occurred_at:    occurrence.occurred_at,
+            request_method: occurrence.request_method,
+            request_url:    occurrence.request_url,
+            request_params: occurrence.request_params.presence,
+            environment:    occurrence.environment,
+            deploy_sha:     occurrence.deploy_sha,
+            backtrace:      Array(occurrence.backtrace)
+          }
+        end
+      end
+    end
+  end
+end