rails_pulse 0.4.0.pre.2 → 0.4.0.pre.6

data/README.md

@@ -1,164 +1,138 @@
 <div align="center">
-  <img src="app/assets/images/rails_pulse/rails-pulse-logo.png" alt="Rails Pulse" width="200" />
+  <img src="app/assets/images/rails_pulse/rails-pulse-logo.png" alt="Rails Pulse" width="160" />
 </div>
 
----
-
 # Rails Pulse
 
-**Self-hosted performance monitoring for Rails apps**
+**Performance monitoring that lives inside your Rails app.** Slow requests, N+1 queries, background jobs and exceptions, stored in your own database. No agent, no account, no data leaving your servers.
 
 ![Gem Version](https://img.shields.io/gem/v/rails_pulse)
 ![Rails Version](https://img.shields.io/badge/Rails-7.2%2B-blue)
+![Ruby Version](https://img.shields.io/badge/Ruby-3.1%2B-red)
 ![License](https://img.shields.io/badge/License-MIT-green)
-![Ruby Version](https://img.shields.io/badge/Ruby-3.0%2B-red)
 
-Rails Pulse is a Rails engine that monitors your app's performance from the inside. It tracks slow requests, N+1 queries, SQL performance, background jobs, and unhandled exceptions. All data stays in your own database, no third-party cloud, no SaaS subscription, no data leaving your servers.
+Rails Pulse is a Rails engine. It hooks into the instrumentation Rails already emits, writes what it sees to a handful of tables, and mounts a dashboard that shows you where the time went. Install the gem, run one migration, schedule two jobs, and you have monitoring that works the same on SQLite, PostgreSQL and MySQL.
+
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset=".github/images/dashboard-dark.png">
+  <img src=".github/images/dashboard-light.png" alt="Rails Pulse dashboard: health bar for routes, queries, jobs, exceptions and storage; P95 response time, request rate and error rate with sparklines; response time percentiles against service level objective lines; and a ranked list of jobs and routes needing attention" width="100%">
+</picture>
+
+## What you get
 
-<table border="0">
-  <tr border="0" style="border:0">
-    <td border="0" style="border:0">
-    <img src="app/assets/images/rails_pulse/dashboard.png" alt="Dashboard" width="400" /></td>
-    <td style="border:0"><img src="app/assets/images/rails_pulse/request-show.png" alt="Request detail" width="400" /></td>
+- **The state of the app in one screen.** A health bar counts healthy, slow and critical routes, queries, jobs and exception groups. A ranked "needs attention" list tells you what to fix first.
+- **Every request, broken down.** Each request stores its route, status, duration and a timeline of the SQL, view, cache, HTTP, mailer and Active Storage operations inside it.
+- **Queries you can act on.** SQL is normalised and fingerprinted, so you see execution counts and P95 per statement shape, N+1 patterns, an EXPLAIN plan and index suggestions.
+- **Jobs and exceptions in the same place.** Duration, queue wait and failure rate for every Active Job class on any adapter. Unhandled exceptions from requests and jobs grouped by class and location, with filtered params and backtraces.
+- **Numbers over time.** Hourly, daily, weekly and monthly summaries with P50, P95 and P99, your service level objectives drawn as lines on the charts, and a marker for every deploy so a regression lines up with the release that caused it.
+- **Built for production.** Tracking is queued off the request thread and dropped rather than blocked under load. If the gem is deployed before its migrations, tracking pauses and tells you what to run. Retention is enforced by age and by row count so the tables never grow without bound.
+
+<table>
+  <tr>
+    <td width="50%" valign="top">
+      <picture>
+        <source media="(prefers-color-scheme: dark)" srcset=".github/images/request-dark.png">
+        <img src=".github/images/request-light.png" alt="Request detail: duration, status and response size, a performance breakdown by database, view and application time, and a request trace showing action, view and database operations on a timeline">
+      </picture>
+      <p align="center"><sub>A request and where its time went</sub></p>
+    </td>
+    <td width="50%" valign="top">
+      <picture>
+        <source media="(prefers-color-scheme: dark)" srcset=".github/images/query-dark.png">
+        <img src=".github/images/query-light.png" alt="Query diagnostics: query characteristics, an issue detected, an optimisation suggestion to add a composite index, and the execution plan">
+      </picture>
+      <p align="center"><sub>Diagnostics and an index suggestion for one query</sub></p>
+    </td>
   </tr>
   <tr>
-    <td style="border:0"><img src="app/assets/images/rails_pulse/query-show.png" alt="Query detail" width="400" /></td>
-    <td style="border:0"><img src="app/assets/images/rails_pulse/route-show.png" alt="Route detail" width="400" /></td>
+    <td colspan="2">
+      <picture>
+        <source media="(prefers-color-scheme: dark)" srcset=".github/images/route-dark.png">
+        <img src=".github/images/route-light.png" alt="Route detail: P95 response time, request rate and error rate cards, and a two-week P95 and P99 chart with service level objective lines and vertical deploy markers">
+      </picture>
+      <p align="center"><sub>One route over two weeks, with objective lines and deploy markers</sub></p>
+    </td>
   </tr>
 </table>
 
-## Installation
-
-Add to your Gemfile:
+## Quick start
 
 ```ruby
-gem 'rails_pulse'
+# Gemfile
+gem "rails_pulse"
 ```
 
-Run the installer:
-
 ```bash
 bundle install
 rails generate rails_pulse:install
 rails db:migrate
 ```
 
-Mount the dashboard in `config/routes.rb`:
-
-```ruby
-Rails.application.routes.draw do
-  mount RailsPulse::Engine => "/rails_pulse"
-end
-```
-
-Schedule the background jobs:
-
 ```ruby
-RailsPulse::SummaryJob.perform_later  # cron: 5 * * * *
-RailsPulse::CleanupJob.perform_later  # cron: 0 1 * * *
+# config/routes.rb
+mount RailsPulse::Engine => "/rails_pulse"
 ```
 
-Your dashboard is now at `http://localhost:3000/rails_pulse`.
-
-## Upgrading
-
-From 0.3.3:
-
-```bash
-bundle update rails_pulse
-rails generate rails_pulse:upgrade
-rails db:migrate                  # or: rails db:migrate:rails_pulse
-rails rails_pulse:migrate_routes  # required — fills Action and merges same-action paths
-```
-
-Restart all processes after migrate. This release changes how routes are stored (`method` moves off the route onto each request), so mixed old/new processes are not supported.
-
-The upgrade generator appends new settings to `config/initializers/rails_pulse.rb` without rewriting what you already set. Review with `git diff` and keep or discard hunks.
-
-Exception tracking is **off** for existing installs. The generator inserts `config.track_exceptions = false`; set it to `true` after migrating to opt in:
-
-```ruby
-config.track_exceptions = true
-config.capture_exception_params = true  # params are filtered via Rails' filter_parameters
+Schedule the summary job hourly and the cleanup job daily with whatever your queue adapter provides. With Solid Queue:
+
+```yaml
+# config/recurring.yml
+production:
+  rails_pulse_summary:
+    class: RailsPulse::SummaryJob
+    schedule: "5 * * * *"
+  rails_pulse_cleanup:
+    class: RailsPulse::CleanupJob
+    schedule: "0 1 * * *"
 ```
 
-Separate-database hosts: set `schema_dump: false` on the `rails_pulse` entry in `config/database.yml` and delete `db/rails_pulse_structure.sql` if that file exists.
-
-If you previously added `rails-pulse.js` / `rails-pulse.css` to `config.assets.precompile`, remove those entries — the gem no longer registers dashboard assets with Sprockets (that re-minify OOMs small hosts). Production deploys that use `config.asset_host` or a CDN-only CSP should run `assets:precompile` so `rails_pulse:install_assets` copies digested files into `public/assets`.
+Open `http://localhost:3000/rails_pulse`. That's the whole setup.
 
-Full install guide: [railspulse.com/documentation/installation](https://railspulse.com/documentation/installation)
+Requirements: Ruby 3.1+, Rails 7.1+ (tested on 7.2, 8.0 and 8.1), SQLite, PostgreSQL or MySQL. Until 0.4.0 ships, pin the pre-release with `gem "rails_pulse", "~> 0.4.0.pre"`.
 
-Separate database setup: [railspulse.com/documentation/database](https://railspulse.com/documentation/database)
+Full install guide, including a separate database and plain cron: [railspulse.com/documentation/installation](https://railspulse.com/documentation/installation)
 
-## Configuration
+## Going further
 
-Rails Pulse works out of the box with sensible defaults. To customise, edit `config/initializers/rails_pulse.rb`:
+**Lock it down.** The dashboard is authenticated by default outside development and test. Point it at your own auth with a predicate; anything but `true` is a 403.
 
 ```ruby
 RailsPulse.configure do |config|
-  config.enabled = true
-
-  config.request_thresholds = {
-    slow: 700,
-    very_slow: 2000,
-    critical: 4000
-  }
-
-  config.track_jobs = true
-  config.capture_job_arguments = false  # keep false to protect sensitive data
-
-  config.track_exceptions = true
-  config.capture_exception_params = true  # params are filtered via Rails' filter_parameters
-
-  config.full_retention_period = 30.days
+  config.authorize = ->(controller) { controller.current_user&.admin? }
 end
 ```
 
-Full configuration reference: [railspulse.com/documentation/advanced](https://railspulse.com/documentation/advanced)
+With nothing configured it falls back to HTTP Basic against `RAILS_PULSE_USERNAME` and `RAILS_PULSE_PASSWORD`. [Authentication guide](https://railspulse.com/documentation/authentication)
 
-## Authentication
+**Tune it.** Thresholds for slow, very slow and critical, service level objectives per percentile, what to ignore, what to tag, how long to keep. All in `config/initializers/rails_pulse.rb`. [Configuration reference](https://railspulse.com/documentation/advanced)
 
-Rails Pulse has no built-in user accounts; you protect the dashboard using your app's existing auth. Authentication is on by default outside development and test, and with nothing configured it falls back to HTTP Basic against `RAILS_PULSE_USERNAME` / `RAILS_PULSE_PASSWORD` (denying everything if the password is unset).
+**Run the dashboard on its own.** `bundle exec rails_pulse_server` serves the UI from a separate process with its own health endpoint, so a slow report never competes with your app for a thread. [Deployment modes](https://railspulse.com/documentation/deployment-modes)
 
-The simplest hook is a predicate that receives the controller and returns `true` to allow — anything else is a 403:
-
-```ruby
-RailsPulse.configure do |config|
-  config.authorize = ->(controller) { controller.current_user&.admin? }
-end
-```
+**Mark your deploys.** `rails rails_pulse:record_deployment[sha]` from a release script, or `POST /rails_pulse/deployments` with a token from CI, and every chart draws a line at that moment.
 
-If you need to redirect to a login page instead, use `authentication_method`, which runs inside the controller and denies by rendering or redirecting:
+**Keep it in its own database.** `rails generate rails_pulse:install --database=separate` puts the tables somewhere your primary never has to vacuum. [Database setup](https://railspulse.com/documentation/database)
 
-```ruby
-RailsPulse.configure do |config|
-  config.authentication_redirect_path = "/login"
+## Upgrading
 
-  config.authentication_method = proc {
-    unless user_signed_in? && current_user.admin?
-      redirect_to main_app.root_path, alert: "Access denied"
-    end
-  }
-end
+```bash
+bundle update rails_pulse
+rails generate rails_pulse:upgrade
+rails db:migrate                  # separate Pulse database: rails db:migrate:rails_pulse
+rails rails_pulse:status          # exits 1 while anything still needs action
 ```
 
-Returning `false` from `authentication_method` without responding is also treated as a denial, but `nil` (what `unless … end` returns on success) allows the request — so keep predicate-style checks in `authorize`.
-
-Authentication guide: [railspulse.com/documentation/authentication](https://railspulse.com/documentation/authentication)
-
-## Features
-
-- **Request monitoring** — every request is timed and stored with its route, status, SQL count, and duration. Slow requests are flagged automatically based on thresholds you control.
-- **Query analysis** — captures the queries behind each request, detects N+1 patterns, and tracks normalized SQL across requests so you can see which queries are hurting you in production, not just in development.
-- **Job tracking** — monitors background job duration, queue wait time, and failure rates. Works with any Active Job adapter.
-- **Exception tracking** — captures unhandled exceptions from web requests and background jobs, groups them by class and location, and shows full backtraces with filtered request params. See recurring errors in production without a separate error monitoring service.
-- **System health bar** — at-a-glance dashboard summary showing healthy, slow, and critical counts across your routes, queries, jobs, and storage. Lets you see the overall state of your app before drilling into specifics.
-- **No data leaves your app** — everything is stored in your own database. No third-party cloud, no SaaS subscription, no outbound connections.
-- **Low overhead** — tracking is async and uses a thread-local flag to skip recording Rails Pulse's own internal requests.
+Upgrading from 0.3.x to 0.4? **Back up first**, run `rails rails_pulse:migrate_routes` after migrating, and restart every process together. The details are in the [changelog](CHANGELOG.md).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on [GitHub](https://github.com/railspulse/rails_pulse).
+Bug reports and pull requests are welcome on [GitHub](https://github.com/railspulse/rails_pulse). `docs/` explains how the pieces fit and why they are built the way they are.
+
+```bash
+git config core.hooksPath .githooks   # once, after cloning
+DB=sqlite3 rake test                  # or DB=postgresql / DB=mysql2
+bundle exec rubocop
+```
 
 ## License
 

data/app/controllers/concerns/session_filters_concern.rb

@@ -24,10 +24,11 @@ module SessionFiltersConcern
     session_global_filters["disabled_tags"] || []
   end
 
-  # Returns the time range preference from session
-  # Can be a symbol/string for presets or a hash for custom ranges
+  # Returns the time range preference from session, normalized so every
+  # session serializer yields the same shape: a String preset name, a
+  # string-keyed Hash for a custom range, or nil for anything unrecognized.
   def session_time_range_preference
-    session[:time_range_preference]
+    RailsPulse::TimeRangePreference.normalize(session[:time_range_preference])
   end
 
   # Returns whether deployment markers should be shown by default

data/app/controllers/concerns/time_range_concern.rb

@@ -41,6 +41,11 @@ module TimeRangeConcern
     end_time = Time.zone.now
     selected_time_range = default_key
 
+    # Normalized up front so a symbol-keyed hash from a Marshal-backed session
+    # store reads the same as the string-keyed one the cookie store produces;
+    # anything unrecognized becomes nil and falls through to later priorities.
+    session_preference = RailsPulse::TimeRangePreference.normalize(session[:time_range_preference])
+
     # Priority 1: Page-specific preset from dropdown (check this first!)
     if ransack_params[:period_start_range].present? && ransack_params[:period_start_range].to_sym != :custom
       # Predefined time range from dropdown
@@ -76,25 +81,22 @@ module TimeRangeConcern
         selected_time_range = :custom
       end
     # Priority 4: Time range selector (from session)
-    elsif session[:time_range_preference].present?
-      preference = session[:time_range_preference]
-      if preference.is_a?(Hash) && preference["type"] == "custom"
-        # Custom range from time range selector
-        start_time = parse_time_param(preference["start_time"]) || start_time
-        end_time = parse_time_param(preference["end_time"]) || end_time
-        selected_time_range = :custom
-      else
-        # Preset from time range selector
-        selected_time_range = preference.to_sym
-        start_time =
-          case selected_time_range
-          when :last_24_hours  then 1.day.ago
-          when :last_7_days    then 1.week.ago
-          when :last_14_days   then 2.weeks.ago
-          when :last_30_days   then 1.month.ago
-          else start_time
-          end
-      end
+    elsif RailsPulse::TimeRangePreference.custom?(session_preference)
+      # Custom range from time range selector
+      start_time = parse_time_param(session_preference["start_time"]) || start_time
+      end_time = parse_time_param(session_preference["end_time"]) || end_time
+      selected_time_range = :custom
+    elsif session_preference.is_a?(String) && session_preference.present?
+      # Preset from time range selector
+      selected_time_range = session_preference.to_sym
+      start_time =
+        case selected_time_range
+        when :last_24_hours  then 1.day.ago
+        when :last_7_days    then 1.week.ago
+        when :last_14_days   then 2.weeks.ago
+        when :last_30_days   then 1.month.ago
+        else start_time
+        end
     # Priority 5: Global filters (from session)
     elsif session_global_filters["start_time"].present? || session_global_filters["end_time"].present?
       start_time = parse_time_param(session_global_filters["start_time"]) || start_time
@@ -105,6 +107,14 @@ module TimeRangeConcern
 
     time_diff = (end_time.to_i - start_time.to_i) / 3600.0
 
+    # in_time_zone before rounding: a parsed custom-range string carries the
+    # server OS's local offset, not Time.zone, and beginning_of_day/_hour
+    # round in whatever offset the receiver has. Summary data is always
+    # bucketed by Time.zone, so without this the boundary can miss every
+    # summary row and render charts empty. No-op for already-Time.zone values.
+    start_time = start_time.in_time_zone
+    end_time = end_time.in_time_zone
+
     if time_diff <= 25
       start_time = start_time.beginning_of_hour
       end_time = end_time.end_of_hour

data/app/controllers/rails_pulse/application_controller.rb

@@ -15,6 +15,7 @@ module RailsPulse
     protect_from_forgery with: :exception
 
     before_action :authenticate_rails_pulse_user!
+    before_action :require_current_schema!
     before_action :set_onboarding_state
     before_action :load_deployment_markers
 
@@ -85,10 +86,12 @@ module RailsPulse
         session[:time_range_preference] = preset if TIME_RANGE_PRESETS.include?(preset)
       elsif start_time && end_time
         # Store custom range
+        # String keys: a Marshal-backed session store would otherwise hand the
+        # symbol keys back verbatim, and the readers expect the JSON shape.
         session[:time_range_preference] = {
-          type: "custom",
-          start_time: start_time,
-          end_time: end_time
+          "type" => "custom",
+          "start_time" => start_time,
+          "end_time" => end_time
         }
       end
 
@@ -132,6 +135,8 @@ module RailsPulse
       config = RailsPulse.configuration
       return unless config.authentication_enabled
 
+      return authenticate_standalone!(config) if RailsPulse.standalone?
+
       if config.authentication_method.nil? && config.authorize.nil?
         return fallback_http_basic_auth
       end
@@ -144,7 +149,41 @@ module RailsPulse
       run_authorize_predicate(config.authorize) if config.authorize
     rescue StandardError => e
       logger.warn "RailsPulse authentication failed: #{e.message}"
-      redirect_to config.authentication_redirect_path
+      # The redirect target is a host app page; from the standalone server
+      # it would point at a route this process does not serve.
+      if RailsPulse.standalone?
+        render plain: "Forbidden", status: :forbidden
+      else
+        redirect_to config.authentication_redirect_path
+      end
+    end
+
+    # The standalone server has the host's models but not its middleware:
+    # no host session store, Warden, or Devise helpers, and a different
+    # hostname so no shared cookie. A session-based `authentication_method`
+    # or `authorize` would raise (rescued above into a useless redirect) or,
+    # worse, be written so that it silently allows. Ignore both here; use
+    # `standalone_authentication_method` when set, else HTTP Basic.
+    def authenticate_standalone!(config)
+      hook = config.standalone_authentication_method
+      if hook.nil?
+        note_ignored_host_authentication(config)
+        return fallback_http_basic_auth
+      end
+
+      run_authentication_method(hook)
+    end
+
+    # Logged once per process, not once per controller: the flag lives on
+    # RailsPulse::Standalone, so RequestsController and QueriesController do
+    # not each repeat it on their first request.
+    def note_ignored_host_authentication(config)
+      return if config.authentication_method.nil? && config.authorize.nil?
+      return unless RailsPulse.note_host_authentication_ignored!
+
+      logger.info "RailsPulse: standalone dashboard ignores config.authentication_method / config.authorize " \
+                  "(host session helpers are not available here); using HTTP Basic auth. " \
+                  "Set config.standalone_authentication_method to customise."
     end
 
     def run_authentication_method(hook)
@@ -196,6 +235,30 @@ module RailsPulse
       end
     end
 
+    # New gem code against un-migrated tables would otherwise 500 on every
+    # page that touches a missing column. Runs after authentication so the
+    # schema report is not exposed to anonymous callers.
+    def require_current_schema!
+      return if RailsPulse::SchemaCheck.current?
+
+      RailsPulse::SchemaCheck.warn_once!
+      missing = RailsPulse::SchemaCheck.missing
+
+      respond_to do |format|
+        format.html do
+          render template: "rails_pulse/shared/schema_outdated", layout: false,
+                 status: :service_unavailable, locals: { missing: missing }
+        end
+        format.any do
+          render json: {
+            error: "Rails Pulse #{RailsPulse::VERSION} requires a schema upgrade",
+            missing: missing,
+            instructions: RailsPulse::SchemaCheck::UPGRADE_INSTRUCTIONS
+          }, status: :service_unavailable
+        end
+      end
+    end
+
     def load_deployment_markers
       @deployment_markers = []
       @show_deployment_markers = session_show_deployment_markers

data/app/controllers/rails_pulse/dashboard_controller.rb

@@ -8,8 +8,11 @@ module RailsPulse
       @start_time, @end_time, @selected_time_range, @time_diff = setup_time_range
       populate_deployment_markers
 
-      # Convert time range to period in days for dashboard cards/charts
-      @period = ((@end_time - @start_time) / 1.day).round
+      # Rounded rather than truncated, so a range a few seconds short of N
+      # whole days still counts as N. Cards/charts also get @start_time/
+      # @end_time directly so they bucket the exact range, not "the last
+      # @period days ending now".
+      @period = RailsPulse::TimeWindow.new(@start_time, @end_time).days
 
       # Determine period type based on time range
       # If 24 hours or less, use hourly summaries, otherwise use daily
@@ -19,22 +22,28 @@ module RailsPulse
       disabled_tags = session_disabled_tags
       show_non_tagged = session[:show_non_tagged] != false
 
-      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, period_type: @period_type).to_metric_card
-      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, period_type: @period_type).to_metric_card
-      @error_rates_metric_card = RailsPulse::Routes::Cards::ErrorRates.new(route: nil, disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, period_type: @period_type).to_metric_card
-      @job_failure_rate_metric_card = RailsPulse::Jobs::Cards::FailureRate.new(period: @period, period_type: @period_type).to_metric_card if RailsPulse.configuration.track_jobs
+      card_and_chart_options = {
+        disabled_tags: disabled_tags, show_non_tagged: show_non_tagged,
+        period: @period, period_type: @period_type,
+        start_time: @start_time, end_time: @end_time
+      }
+
+      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil, **card_and_chart_options).to_metric_card
+      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil, **card_and_chart_options).to_metric_card
+      @error_rates_metric_card = RailsPulse::Routes::Cards::ErrorRates.new(route: nil, **card_and_chart_options).to_metric_card
+      @job_failure_rate_metric_card = RailsPulse::Jobs::Cards::FailureRate.new(**card_and_chart_options).to_metric_card if RailsPulse.configuration.track_jobs
 
       # Generate chart data for inline rendering
-      @response_time_percentiles_chart_data = RailsPulse::Dashboard::Charts::ResponseTimePercentiles.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, period_type: @period_type).to_chart_data
-      @throughput_and_errors_chart_data = RailsPulse::Dashboard::Charts::ThroughputAndErrors.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, period_type: @period_type).to_chart_data
+      @response_time_percentiles_chart_data = RailsPulse::Dashboard::Charts::ResponseTimePercentiles.new(**card_and_chart_options).to_chart_data
+      @throughput_and_errors_chart_data = RailsPulse::Dashboard::Charts::ThroughputAndErrors.new(**card_and_chart_options).to_chart_data
 
       # Needs Attention panel
-      @needs_attention = RailsPulse::Dashboard::NeedsAttention.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period).to_attention_data
+      @needs_attention = RailsPulse::Dashboard::NeedsAttention.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, start_time: @start_time, end_time: @end_time).to_attention_data
 
       # System Health bar
-      @health_summary = RailsPulse::Dashboard::HealthSummary.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period).to_health_data
+      @health_summary = RailsPulse::Dashboard::HealthSummary.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, start_time: @start_time, end_time: @end_time).to_health_data
 
-      @storage_status = RailsPulse::Dashboard::StorageStatus.new
+      @storage_status = RailsPulse::Dashboard::StorageStatus.new(cached_sizes: true)
 
       # Deployments panel — scoped to the same window as the chart markers so
       # the panel and the markers drawn on the charts always agree.

data/app/controllers/rails_pulse/deployments_controller.rb

@@ -36,10 +36,7 @@ module RailsPulse
     end
 
     def finish
-      deployment = RailsPulse::Deployment
-        .where(revision: finish_params[:revision])
-        .order(started_at: :desc)
-        .first
+      deployment = RailsPulse::Deployment.latest_for_revision(finish_params[:revision])
 
       return render json: { status: "error", error: "Deployment not found" }, status: :not_found unless deployment
 

data/app/controllers/rails_pulse/routes_controller.rb

@@ -14,6 +14,7 @@ module RailsPulse
     def show
       setup_metric_cards
       setup_chart_and_table_data
+      setup_archived_summary_data
     end
 
     private
@@ -126,6 +127,51 @@ module RailsPulse
       @route = Route.find(params[:id])
     end
 
+    ARCHIVED_SUMMARY_PAGE_LIMIT = 20
+
+    # Raw Request rows get purged by CleanupService after full_retention_period.
+    # For any part of the selected window older than that cutoff, fall back to
+    # pre-aggregated Summary rows (which CleanupService never deletes for
+    # day/week/month periods) so the table isn't just blank for old ranges.
+    def setup_archived_summary_data
+      cutoff = retention_cutoff
+      window_start = @page_timings&.table_start_time
+
+      scope = if cutoff && window_start && Time.at(window_start) < cutoff
+        scope = Summary.for_routes
+          .where(summarizable_id: @route.id)
+          .where(period_type: period_type)
+          .where("period_start < ?", cutoff)
+
+        if @page_timings&.table_end_time
+          scope = scope.where("period_start < ?", Time.at(@page_timings.table_end_time))
+        end
+
+        scope.order(period_start: :desc)
+      else
+        Summary.none
+      end
+
+      @archived_pagination, @archived_summary_data =
+        paginate_archived(scope, limit: ARCHIVED_SUMMARY_PAGE_LIMIT)
+    end
+
+    # Mirrors PaginationConcern#paginate but keys off its own `archived_page`
+    # param so the archived table's pagination doesn't fight over the same
+    # `page`/`limit` params as the live requests table above it on the page.
+    def paginate_archived(collection, limit:)
+      page = [ params[:archived_page].to_i, 1 ].max
+      paginator = RailsPulse::Paginator.new(count: collection.count(:all), page: page, limit: limit)
+      records = collection.offset((paginator.page - 1) * limit).limit(limit)
+      [ paginator, records ]
+    end
+
+    def retention_cutoff
+      config = RailsPulse.configuration rescue nil
+      period = config&.full_retention_period
+      period ? period.ago : nil
+    end
+
     def ordering_by_computed_column?
       # Check if we're ordering by status_indicator (computed column)
       @ransack_query.sorts.any? { |sort| sort.name == "status_indicator" }

data/app/helpers/rails_pulse/application_helper.rb

@@ -31,5 +31,9 @@ module RailsPulse
     def page_url(page_number)
       url_for(request.query_parameters.merge(page: page_number))
     end
+
+    def archived_page_url(page_number)
+      url_for(request.query_parameters.merge(archived_page: page_number, anchor: "archived-data"))
+    end
   end
 end

data/app/helpers/rails_pulse/breadcrumbs_helper.rb

@@ -30,13 +30,16 @@ module RailsPulse
       # Only keep segments after the mount point
       path_segments = path_segments[(mount_end_index + 1)..-1]
 
-      # Build the engine root path directly from mount segments (avoids relying on named route helper)
-      engine_root = "/" + mount_segments.join("/")
+      # Build the engine root path directly from mount segments (avoids relying on named route helper).
+      # Served at "/" (standalone server, or a host that mounts the engine at root) the prefix
+      # is empty, not "/": segments are appended as "/#{segment}", and "/" + "/queries" would be
+      # "//queries" — a protocol-relative URL that browsers resolve to a host called "queries".
+      engine_root = mount_segments.empty? ? "" : "/" + mount_segments.join("/")
 
       # Start with the Home link
       crumbs = [ {
         title: "Home",
-        path: engine_root,
+        path: engine_root.empty? ? "/" : engine_root,
         current: path_segments.empty?
       } ]
 

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

@@ -160,6 +160,12 @@ export default class extends Controller {
       config.xAxis = config.xAxis || {}
       if (isTimePairs) {
         config.xAxis.type = 'time'
+        // Without this, ECharts spaces ticks by pixel width, not by the data's
+        // actual bucket size — a multi-day "time" axis can end up with more
+        // ticks than days, and since the label formatter only shows the date,
+        // adjacent ticks on the same day render as duplicate-looking labels.
+        const bucketMs = this._minTimestampGapMs(data.series)
+        if (bucketMs) config.xAxis.minInterval = bucketMs
       } else {
         config.xAxis.type = 'category'
         config.xAxis.data = data.labels
@@ -240,6 +246,27 @@ export default class extends Controller {
     return Array.isArray(firstPoint) || Array.isArray(firstPoint?.value)
   }
 
+  // Smallest gap (ms) between any two distinct timestamps across all series,
+  // used as xAxis.minInterval so auto-placed ticks never fall closer together
+  // than the data actually does.
+  _minTimestampGapMs(series) {
+    const timestamps = new Set()
+    series.forEach(s => {
+      (s.data || []).forEach(point => {
+        const pair = Array.isArray(point) ? point : (Array.isArray(point?.value) ? point.value : null)
+        if (pair && typeof pair[0] === 'number') timestamps.add(pair[0])
+      })
+    })
+
+    const sorted = Array.from(timestamps).sort((a, b) => a - b)
+    let minGap = null
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i] - sorted[i - 1]
+      if (gap > 0 && (minGap === null || gap < minGap)) minGap = gap
+    }
+    return minGap
+  }
+
   deploymentMarkerSeriesId = 'rails-pulse-deployment-markers'
 
   _buildDeploymentMarkerSeries(markers, visible = true) {