rails_pulse 0.4.0.pre.4 → 0.4.0

data/app/services/rails_pulse/summary_service.rb

@@ -1,6 +1,15 @@
-
 module RailsPulse
+  # Aggregates one period (hour, day, week or month) of requests, operations,
+  # job runs and exception occurrences into rails_pulse_summaries rows.
+  #
+  # Rows are written with upsert_all against the summaries table's unique
+  # index, one statement per summarizable kind, so re-running a period (the
+  # backfill task, a retried SummaryJob) overwrites rather than duplicates and
+  # a period with hundreds of routes costs a handful of statements instead of
+  # two per route.
   class SummaryService
+    UNIQUE_INDEX = :idx_pulse_summaries_unique
+
     attr_reader :period_type, :start_time, :end_time
 
     def initialize(period_type, start_time)
@@ -12,12 +21,13 @@ module RailsPulse
     def perform
       RailsPulse.logger.info "Starting #{period_type} summary for #{start_time}"
 
-      ActiveRecord::Base.transaction do
-        aggregate_requests  # Overall system metrics
-        aggregate_routes    # Per-route metrics
-        aggregate_queries   # Per-query metrics
-        aggregate_jobs      # Per-job metrics
-        aggregate_exceptions # Per-exception-group frequency
+      # The engine's own connection: on a separate-database install
+      # ActiveRecord::Base would open the transaction on the host's primary.
+      RailsPulse::ApplicationRecord.transaction do
+        upsert_summaries(request_summary_rows + route_summary_rows) # Overall and per-route
+        upsert_summaries(query_summary_rows)                        # Per-query
+        upsert_summaries(job_summary_rows)                          # Per-job
+        aggregate_exceptions                                        # Per-exception-group frequency
       end
 
       RailsPulse.logger.info "Completed #{period_type} summary"
@@ -28,89 +38,125 @@ module RailsPulse
 
     private
 
-    def aggregate_requests
-      # Create a single summary for ALL requests in this period
-      requests = Request.where(occurred_at: start_time...end_time)
-
-      return if requests.empty?
+    # Every row in one call must have the same keys, which is why the
+    # summarizable kinds are upserted separately: request and route rows carry
+    # status columns, query rows do not, exception rows carry only a count.
+    def upsert_summaries(rows)
+      return if rows.empty?
 
-      # Get all durations and statuses for percentile calculations
-      request_data = requests.pluck(:duration, :status)
-      durations = request_data.map(&:first).compact.sort
-      statuses = request_data.map(&:second)
+      # MySQL resolves the conflict through any unique key and rejects an
+      # explicit target.
+      unique_by = Summary.connection.supports_insert_conflict_target? ? UNIQUE_INDEX : nil
+      Summary.upsert_all(rows, unique_by: unique_by)
+    end
 
-      # Find or create the overall request summary
-      summary = Summary.find_or_initialize_by(
-        summarizable_type: "RailsPulse::Request",
-        summarizable_id: 0,  # Use 0 as a special ID for overall summaries
+    def summary_row(summarizable_type, summarizable_id)
+      {
+        summarizable_type: summarizable_type,
+        summarizable_id: summarizable_id,
         period_type: period_type,
-        period_start: start_time
-      )
+        period_start: start_time,
+        period_end: end_time
+      }
+    end
+
+    # `durations` must be sorted. Empty input yields count 0 and nil
+    # percentiles, which is what an idle period should record.
+    def duration_metrics(durations)
+      avg = durations.any? ? durations.sum.to_f / durations.size : 0
 
-      summary.assign_attributes(
-        period_end: end_time,
+      {
         count: durations.size,
-        avg_duration: durations.any? ? durations.sum.to_f / durations.size : 0,
-        min_duration: durations.min,
-        max_duration: durations.max,
+        avg_duration: avg,
+        min_duration: durations.first,
+        max_duration: durations.last,
         total_duration: durations.sum,
         p50_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.5),
         p95_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.95),
         p99_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.99),
-        stddev_duration: RailsPulse::Statistics.calculate_stddev(durations, durations.sum.to_f / durations.size),
+        stddev_duration: RailsPulse::Statistics.calculate_stddev(durations, avg)
+      }
+    end
+
+    def status_metrics(statuses)
+      {
         error_count: statuses.count { |s| s >= 500 },
         success_count: statuses.count { |s| s < 500 },
         status_2xx: statuses.count { |s| s.between?(200, 299) },
         status_3xx: statuses.count { |s| s.between?(300, 399) },
         status_4xx: statuses.count { |s| s.between?(400, 499) },
         status_5xx: statuses.count { |s| s >= 500 }
-      )
-
-      summary.save!
+      }
     end
 
-    private
+    # One row for ALL requests in the period, written even when the period is
+    # empty (count: 0) so its timestamp keeps advancing every period — it is
+    # the heartbeat several health checks use to detect whether SummaryJob is
+    # still running (dashboard banner, rails_pulse:status, StoragePressure
+    # staleness, and CleanupService's summarized_cutoff). summarizable_id 0
+    # marks the overall rollup.
+    def request_summary_rows
+      request_data = Request.where(occurred_at: start_time...end_time).pluck(:duration, :status)
+      durations = request_data.map(&:first).compact.sort
+      statuses = request_data.map(&:second)
+
+      [ summary_row("RailsPulse::Request", 0).merge(duration_metrics(durations), status_metrics(statuses)) ]
+    end
 
-    def aggregate_routes
+    def route_summary_rows
       all_rows = Request
         .where(occurred_at: start_time...end_time)
         .where.not(route_id: nil)
         .pluck(:route_id, :duration, :status)
 
-      return if all_rows.empty?
-
-      all_rows.group_by(&:first).each do |route_id, rows|
+      all_rows.group_by(&:first).map do |route_id, rows|
         durations = rows.map { |_, d, _| d }.compact.sort
         statuses = rows.map { |_, _, s| s }
-        avg = durations.sum.to_f / durations.size
 
-        summary = Summary.find_or_initialize_by(
-          summarizable_type: "RailsPulse::Route",
-          summarizable_id: route_id,
-          period_type: period_type,
-          period_start: start_time
-        )
+        summary_row("RailsPulse::Route", route_id)
+          .merge(duration_metrics(durations), status_metrics(statuses), count: rows.size)
+      end
+    end
 
-        summary.assign_attributes(
-          period_end: end_time,
-          count: rows.size,
-          avg_duration: avg,
-          min_duration: durations.first,
-          max_duration: durations.last,
-          total_duration: durations.sum,
-          p50_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.5),
-          p95_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.95),
-          p99_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.99),
-          stddev_duration: RailsPulse::Statistics.calculate_stddev(durations, avg),
-          error_count: statuses.count { |s| s >= 500 },
-          success_count: statuses.count { |s| s < 500 },
-          status_2xx: statuses.count { |s| s.between?(200, 299) },
-          status_3xx: statuses.count { |s| s.between?(300, 399) },
-          status_4xx: statuses.count { |s| s.between?(400, 499) },
-          status_5xx: statuses.count { |s| s >= 500 }
-        )
+    def query_summary_rows
+      all_rows = Operation
+        .where(occurred_at: start_time...end_time)
+        .where.not(query_id: nil)
+        .pluck(:query_id, :duration)
+
+      all_rows.group_by(&:first).filter_map do |query_id, rows|
+        durations = rows.map(&:last).compact.sort
+        next if durations.empty?
+
+        summary_row("RailsPulse::Query", query_id).merge(duration_metrics(durations))
+      end
+    end
+
+    def job_summary_rows
+      all_rows = JobRun
+        .where(occurred_at: start_time...end_time)
+        .where(status: JobRun::FINAL_STATUSES)
+        .where.not(job_id: nil)
+        .pluck(:job_id, :duration, :status)
+      return [] if all_rows.empty?
+
+      # A run whose job row has gone (count-based cleanup) has nothing to
+      # summarize against.
+      known_job_ids = Job.where(id: all_rows.map(&:first).uniq).pluck(:id).to_set
 
-        summary.save!
+      all_rows.group_by(&:first).filter_map do |job_id, runs|
+        next unless known_job_ids.include?(job_id)
+
+        durations = runs.map { |_, d, _| d }.compact.map(&:to_f).sort
+        next if durations.empty?
+
+        statuses = runs.map { |_, _, s| s }
+        summary_row("RailsPulse::Job", job_id).merge(
+          duration_metrics(durations),
+          count: runs.size,
+          error_count: statuses.count { |s| s != "success" },
+          success_count: statuses.count { |s| s == "success" }
+        )
       end
     end
 
@@ -132,113 +178,17 @@ module RailsPulse
 
       return if counts.empty?
 
-      counts.each do |group_id, occurrences|
-        upsert_exception_summary(group_id, occurrences)
-      end
-
+      rows = counts.map { |group_id, occurrences| summary_row("RailsPulse::ExceptionGroup", group_id).merge(count: occurrences) }
       # A rollup across every group, so the dashboard can chart total exception
       # volume without loading one series per group.
-      upsert_exception_summary(0, counts.values.sum)
+      rows << summary_row("RailsPulse::ExceptionGroup", 0).merge(count: counts.values.sum)
+
+      upsert_summaries(rows)
     rescue ActiveRecord::ActiveRecordError => e
       # Exceptions are the newest summarizable and the only optional one. A
       # failure here must not lose the route, query and job summaries that were
       # written in the same transaction.
       RailsPulse.logger.error "Exception summary skipped: #{e.message}"
     end
-
-    def upsert_exception_summary(group_id, occurrences)
-      summary = Summary.find_or_initialize_by(
-        summarizable_type: "RailsPulse::ExceptionGroup",
-        summarizable_id: group_id,
-        period_type: period_type,
-        period_start: start_time
-      )
-
-      summary.assign_attributes(period_end: end_time, count: occurrences)
-      summary.save!
-    end
-
-    def aggregate_queries
-      all_rows = Operation
-        .where(occurred_at: start_time...end_time)
-        .where.not(query_id: nil)
-        .pluck(:query_id, :duration)
-
-      return if all_rows.empty?
-
-      all_rows.group_by(&:first).each do |query_id, rows|
-        durations = rows.map(&:last).compact.sort
-        next if durations.empty?
-
-        avg = durations.sum.to_f / durations.size
-
-        summary = Summary.find_or_initialize_by(
-          summarizable_type: "RailsPulse::Query",
-          summarizable_id: query_id,
-          period_type: period_type,
-          period_start: start_time
-        )
-
-        summary.assign_attributes(
-          period_end: end_time,
-          count: durations.size,
-          avg_duration: avg,
-          min_duration: durations.first,
-          max_duration: durations.last,
-          total_duration: durations.sum,
-          p50_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.5),
-          p95_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.95),
-          p99_duration: RailsPulse::Statistics.calculate_percentile(durations, 0.99),
-          stddev_duration: RailsPulse::Statistics.calculate_stddev(durations, avg)
-        )
-
-        summary.save!
-      end
-    end
-
-    def aggregate_jobs
-      job_runs = JobRun
-        .includes(:job)
-        .where(occurred_at: start_time...end_time)
-        .where(status: JobRun::FINAL_STATUSES)
-
-      return if job_runs.empty?
-
-      job_runs.group_by(&:job_id).each do |job_id, runs|
-        job = runs.first&.job
-        next unless job
-
-        duration_values = runs.map(&:duration).compact.map(&:to_f).sort
-        next if duration_values.empty?
-
-        duration_count = duration_values.size
-        total_duration = duration_values.sum
-        average_duration = total_duration / duration_count
-
-        summary = Summary.find_or_initialize_by(
-          summarizable_type: "RailsPulse::Job",
-          summarizable_id: job.id,
-          period_type: period_type,
-          period_start: start_time
-        )
-
-        summary.assign_attributes(
-          period_end: end_time,
-          count: runs.size,
-          avg_duration: average_duration,
-          min_duration: duration_values.first,
-          max_duration: duration_values.last,
-          total_duration: total_duration,
-          p50_duration: RailsPulse::Statistics.calculate_percentile(duration_values, 0.5),
-          p95_duration: RailsPulse::Statistics.calculate_percentile(duration_values, 0.95),
-          p99_duration: RailsPulse::Statistics.calculate_percentile(duration_values, 0.99),
-          stddev_duration: RailsPulse::Statistics.calculate_stddev(duration_values, average_duration),
-          error_count: runs.count(&:failure_like_status?),
-          success_count: runs.count { |run| run.status == "success" }
-        )
-
-        summary.save!
-      end
-    end
   end
 end

data/app/services/rails_pulse/tag_filter_service.rb

@@ -6,6 +6,15 @@ module RailsPulse
     # @param show_non_tagged [Boolean] Whether to include non-tagged items
     # @return [Array<Integer>] Filtered IDs
     def self.filter_ids(model_class, disabled_tags, show_non_tagged)
+      scope(model_class, disabled_tags, show_non_tagged).pluck(:id)
+    end
+
+    # The same filter as a relation, for use as a subquery. Summary
+    # .with_tag_filters embeds it in an IN (SELECT id ...) so the database
+    # applies the tag filter itself instead of the app plucking every route,
+    # query and job id and sending them back inline on each card's query.
+    # @return [ActiveRecord::Relation]
+    def self.scope(model_class, disabled_tags, show_non_tagged)
       relation = model_class.all
 
       # Exclude items with disabled tags. Explicit ESCAPE: SQLite has no
@@ -21,7 +30,7 @@ module RailsPulse
         relation = relation.where("tags IS NOT NULL AND tags != '[]'")
       end
 
-      relation.pluck(:id)
+      relation
     end
 
     # Main entry point for tag filtering

data/app/views/layouts/rails_pulse/_time_range_selector.html.erb

@@ -1,9 +1,9 @@
 <% preference = session_time_range_preference
 
-if preference.is_a?(Hash) && preference["type"] == "custom"
+if RailsPulse::TimeRangePreference.custom?(preference)
   current_selection = :custom
   current_label = "#{preference["start_time"]} to #{preference["end_time"]}"
-elsif preference.present?
+elsif preference.is_a?(String) && preference.present?
   current_selection = preference.to_sym
   current_label =
     case current_selection

data/app/views/rails_pulse/dashboard/index.html.erb

@@ -4,16 +4,19 @@
       <%= render "rails_pulse/dashboard/health_badge",
       name: "Routes",
       health: @health_summary[:routes],
-      critical_label: "critical" %>
+      critical_label: "critical",
+      link_url: routes_path %>
       <%= render "rails_pulse/dashboard/health_badge",
       name: "Queries",
       health: @health_summary[:queries],
-      critical_label: "critical" %>
+      critical_label: "critical",
+      link_url: queries_path %>
       <% if @health_summary[:jobs] %>
         <%= render "rails_pulse/dashboard/health_badge",
         name: "Jobs",
         health: @health_summary[:jobs],
-        critical_label: "failing" %>
+        critical_label: "failing",
+        link_url: jobs_path %>
       <% end %>
       <%# Nil when exception tracking is off, or when the tables have not been
           migrated yet — which is also when exceptions_path does not exist. %>

data/app/views/rails_pulse/routes/_archived_summary_table.html.erb

@@ -0,0 +1,46 @@
+<% columns = [
+  { field: :period_start, label: 'Time Period', class: 'w-auto', sortable: false },
+  { field: :count, label: 'Requests', class: 'w-32', sortable: false },
+  { field: :avg_duration, label: 'Avg Duration', class: 'w-32', sortable: false },
+  { field: :min_duration, label: 'Min Duration', class: 'w-32', sortable: false },
+  { field: :max_duration, label: 'Max Duration', class: 'w-32', sortable: false }
+] %>
+
+<table class="table mbs-4">
+  <%= render "rails_pulse/components/table_head", columns: columns %>
+
+  <tbody>
+    <% @archived_summary_data.each do |summary| %>
+      <%
+        avg_duration_ms = summary.avg_duration&.round(2) || 0
+        performance_class = case avg_duration_ms
+        when 0..100 then "text-green-600"
+        when 100..300 then "text-yellow-600"
+        when 300..1000 then "text-orange-600"
+        else "text-red-600"
+        end
+      %>
+      <tr>
+        <td class="whitespace-nowrap">
+          <%= human_readable_summary_period(summary) %>
+        </td>
+        <td class="whitespace-nowrap text-center">
+          <span class="font-medium"><%= summary.count %></span>
+        </td>
+        <td class="whitespace-nowrap">
+          <span class="<%= performance_class %> font-medium">
+            <%= avg_duration_ms %> ms
+          </span>
+        </td>
+        <td class="whitespace-nowrap text-center">
+          <%= summary.min_duration&.round(2) || 0 %> ms
+        </td>
+        <td class="whitespace-nowrap text-center">
+          <%= summary.max_duration&.round(2) || 0 %> ms
+        </td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>
+
+<%= render "rails_pulse/routes/archived_table_pagination" %>

data/app/views/rails_pulse/routes/_archived_table_pagination.html.erb

@@ -0,0 +1,28 @@
+<div class="flex items-center mbs-4">
+  <div class="text-sm text-subtle show@md">Total of <%= @archived_pagination.count %> archived period(s).</div>
+
+  <div class="flex items-center mis-auto justify-end" style="column-gap: 1rem">
+    <div class="text-sm font-medium"><%= "Page #{@archived_pagination.page} of #{@archived_pagination.last}" %></div>
+
+    <nav class="flex items-center gap shrink-0" style="--btn-padding: .5rem;" aria-label="Archived data pagination">
+      <% prev_page = @archived_pagination.previous %>
+      <% next_page = @archived_pagination.next %>
+      <%= link_to archived_page_url(1), class: "btn", aria: { disabled: prev_page.nil? }.compact_blank do %>
+        <%= rails_pulse_icon 'chevrons-left', width: '16', height: '16' %>
+        <span class="sr-only">Go to first page</span>
+      <% end %>
+      <%= link_to archived_page_url(prev_page || @archived_pagination.page), class: "btn", aria: { disabled: prev_page.nil? }.compact_blank do %>
+        <%= rails_pulse_icon 'chevron-left', width: '16', height: '16' %>
+        <span class="sr-only">Go to previous page</span>
+      <% end %>
+      <%= link_to archived_page_url(next_page || @archived_pagination.page), class: "btn", aria: { disabled: next_page.nil? }.compact_blank do %>
+        <%= rails_pulse_icon 'chevron-right', width: '16', height: '16' %>
+        <span class="sr-only">Go to next page</span>
+      <% end %>
+      <%= link_to archived_page_url(@archived_pagination.last), class: "btn", aria: { disabled: next_page.nil? }.compact_blank do %>
+        <%= rails_pulse_icon 'chevrons-right', width: '16', height: '16' %>
+        <span class="sr-only">Go to last page</span>
+      <% end %>
+    </nav>
+  </div>
+</div>

data/app/views/rails_pulse/routes/show.html.erb

@@ -45,9 +45,21 @@
 
       <div data-controller="rails-pulse--table-sort">
         <div id="index_table" data-rails-pulse--index-target="indexTable" data-rails-pulse--table-sort-target="tableFrame">
-          <% if @table_data && @table_data.any? %>
+          <% has_requests = @table_data && @table_data.any? %>
+          <% has_archived_summaries = @archived_summary_data && @archived_summary_data.any? %>
+
+          <% if has_requests %>
             <%= render 'rails_pulse/routes/requests_table' %>
-          <% else %>
+          <% end %>
+
+          <% if has_archived_summaries %>
+            <h3 id="archived-data" class="text-sm font-semibold text-subtle mbs-8 mbe-2">
+              Archived data (older than the retention window — aggregated by period)
+            </h3>
+            <%= render 'rails_pulse/routes/archived_summary_table' %>
+          <% end %>
+
+          <% unless has_requests || has_archived_summaries %>
             <%= render 'rails_pulse/components/empty_state',
                 title: 'No route requests found for the selected filters.',
                 description: 'Try adjusting your time range or filters to see results.' %>

data/lib/generators/rails_pulse/install_generator.rb

@@ -86,8 +86,11 @@ module RailsPulse
           db/rails_pulse_structure.sql. Keep database_tasks enabled so
           rails db:migrate:rails_pulse still runs upgrades.
 
-          2. Run: rails db:prepare (creates database and loads schema)
-          3. Restart your Rails server
+          2. Uncomment config.connects_to in config/initializers/rails_pulse.rb
+             so Rails Pulse models use the rails_pulse connection. Without it
+             every model keeps writing to your primary database.
+          3. Run: rails db:prepare (creates database and loads schema)
+          4. Restart your Rails server
 
           The schema file db/rails_pulse_schema.rb is your single source of truth.
           Future upgrades will automatically copy new migrations to db/rails_pulse_migrate/

data/lib/generators/rails_pulse/templates/rails_pulse.rb

@@ -314,7 +314,7 @@ RailsPulse.configure do |config|
   #   end
   # }
 
-  # STANDALONE DASHBOARD (bin/rails_pulse_server, see docs/deployment-modes.md):
+  # STANDALONE DASHBOARD (bundle exec rails_pulse_server; see railspulse.com/documentation/deployment-modes):
   # that process has your models but not your app's session, Warden or Devise
   # helpers, and runs on its own hostname, so the hooks above are ignored there.
   # By default it uses HTTP Basic auth (RAILS_PULSE_USERNAME / RAILS_PULSE_PASSWORD).
@@ -430,10 +430,15 @@ RailsPulse.configure do |config|
   # Use a custom logger (default: Rails.logger)
   # config.logger = Logger.new("log/rails_pulse.log")
 
-  # Perform tracking writes in a background thread (default: true).
+  # Perform tracking writes on a background thread (default: true).
   # When false, writes happen inline before the response is sent.
   # config.async = true
 
+  # How many requests the background writer may hold before it starts dropping
+  # the newest ones instead of slowing the app down (default: 1000). Drops are
+  # counted and logged at most once a minute.
+  # config.async_queue_size = 1000
+
   # Show a dashboard banner when summary data is stale (default: true)
   # config.warn_on_stale_summaries = true
 

data/lib/rails_pulse/cleanup_service.rb

@@ -125,14 +125,14 @@ module RailsPulse
     def cleanup_queries_by_time(cutoff_time)
       RailsPulse::Query
         .where("created_at < ?", cutoff_time)
-        .where("id NOT IN (SELECT query_id FROM rails_pulse_operations WHERE query_id IS NOT NULL)")
+        .where("NOT EXISTS (SELECT 1 FROM rails_pulse_operations WHERE rails_pulse_operations.query_id = rails_pulse_queries.id)")
         .delete_all
     end
 
     def cleanup_routes_by_time(cutoff_time)
       RailsPulse::Route
         .where("created_at < ?", cutoff_time)
-        .where("id NOT IN (SELECT route_id FROM rails_pulse_requests WHERE route_id IS NOT NULL)")
+        .where("NOT EXISTS (SELECT 1 FROM rails_pulse_requests WHERE rails_pulse_requests.route_id = rails_pulse_routes.id)")
         .delete_all
     end
 
@@ -145,7 +145,7 @@ module RailsPulse
     def cleanup_jobs_by_time(cutoff_time)
       RailsPulse::Job
         .where("created_at < ?", cutoff_time)
-        .where("id NOT IN (SELECT job_id FROM rails_pulse_job_runs WHERE job_id IS NOT NULL)")
+        .where("NOT EXISTS (SELECT 1 FROM rails_pulse_job_runs WHERE rails_pulse_job_runs.job_id = rails_pulse_jobs.id)")
         .delete_all
     end
 
@@ -193,21 +193,21 @@ module RailsPulse
 
     def cleanup_queries_by_count
       scope = RailsPulse::Query.where(
-        "id NOT IN (SELECT query_id FROM rails_pulse_operations WHERE query_id IS NOT NULL)"
+        "NOT EXISTS (SELECT 1 FROM rails_pulse_operations WHERE rails_pulse_operations.query_id = rails_pulse_queries.id)"
       )
       cleanup_by_count(RailsPulse::Query, :rails_pulse_queries, order_column: :created_at, scope: scope)
     end
 
     def cleanup_routes_by_count
       scope = RailsPulse::Route.where(
-        "id NOT IN (SELECT route_id FROM rails_pulse_requests WHERE route_id IS NOT NULL)"
+        "NOT EXISTS (SELECT 1 FROM rails_pulse_requests WHERE rails_pulse_requests.route_id = rails_pulse_routes.id)"
       )
       cleanup_by_count(RailsPulse::Route, :rails_pulse_routes, order_column: :created_at, scope: scope)
     end
 
     def cleanup_jobs_by_count
       scope = RailsPulse::Job.where(
-        "id NOT IN (SELECT job_id FROM rails_pulse_job_runs WHERE job_id IS NOT NULL)"
+        "NOT EXISTS (SELECT 1 FROM rails_pulse_job_runs WHERE rails_pulse_job_runs.job_id = rails_pulse_jobs.id)"
       )
       cleanup_by_count(RailsPulse::Job, :rails_pulse_jobs, order_column: :created_at, scope: scope)
     end
@@ -276,7 +276,7 @@ module RailsPulse
       RailsPulse::ExceptionGroup
         .where(preserve: false)
         .where.not(status: "ignored")
-        .where("id NOT IN (SELECT DISTINCT exception_group_id FROM rails_pulse_exception_occurrences)")
+        .where("NOT EXISTS (SELECT 1 FROM rails_pulse_exception_occurrences WHERE rails_pulse_exception_occurrences.exception_group_id = rails_pulse_exception_groups.id)")
         .delete_all
     end
 

data/lib/rails_pulse/configuration.rb

@@ -30,6 +30,7 @@ module RailsPulse
                   :mount_dashboard,
                   :logger,
                   :async,
+                  :async_queue_size,
                   :service_level_objectives,
                   :query_service_level_objectives,
                   :warn_on_stale_summaries,
@@ -126,8 +127,11 @@ module RailsPulse
       @mount_dashboard = true
       @logger = nil
 
-      # Tracking mode settings
+      # Tracking mode settings. With async, one writer thread per process
+      # drains a queue of this many pending requests; when it is full the
+      # newest request is dropped rather than blocking the host.
       @async = true
+      @async_queue_size = 1_000
 
       # Service Level Objectives (default: [] = no SLOs configured)
       @service_level_objectives = []
@@ -397,6 +401,10 @@ module RailsPulse
       unless [ true, false ].include?(@async)
         raise ArgumentError, "async must be true or false, got #{@async}"
       end
+
+      unless @async_queue_size.is_a?(Integer) && @async_queue_size.positive?
+        raise ArgumentError, "async_queue_size must be a positive integer, got #{@async_queue_size.inspect}"
+      end
     end
 
     def validate_exception_settings!