rails_pulse 0.4.0.pre.4 → 0.4.0.pre.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50a1c2016eee54e3ceda7d6e390669b7dc3f427a637cc975a50e9d682262411a
-  data.tar.gz: dfd20c8b99bdb1f3986aa143fb8cfe5aaf3935f7ba7cd43e4c6883721de30ad7
+  metadata.gz: b24fa9677dc2c9b2dd4042acadb464247dd64d2136836e2197a1afe5b90f3f21
+  data.tar.gz: 2c45d0508fb24753b4d65b87b57afb19382b82277747a532e5182d6a6e2a8bdd
 SHA512:
-  metadata.gz: caaf4f2932c7c639e7684fe3a8f4a789b4fe2d7a6b888d9cbeaf302487319efe758b91699f0eef1372cdad385f12269a1a78d9989bf29f855c20bf86c1c322e2
-  data.tar.gz: 852e0524002c525ca784c981c21234a750a2e5d9bc29024290c49d653df4fc806edd0c23e767b9e26be945ed81fafa37cf7474a7354e89ff533cf92a142eafda
+  metadata.gz: 83270431a2752bb64ada4380744b5fc087696c36109bfcdd157412eb9689124e0dc8d1945371978455a8a2baefceced920ff27f82c3d311c4cd297b73f8ae52f
+  data.tar.gz: d3c00d842cebe64770e3039e0c50b029bdde9169590857ec17526a8a05bad7abf71eecebe0fe614ebd1f726a5567d8c4070f08831ccc5847b28c0018184c9ced

data/CHANGELOG.md

@@ -7,8 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0.pre.6] - 2026-09-20
+
+## [0.4.0.pre.5] - 2026-09-20
+
+### Changed
+
+- **Services now autoload through Zeitwerk.** `app/services` was hidden from the Rails autoloader and wired up by hand, so services never reloaded in development and every new one had to be registered in the engine. They now load and reload like the rest of `app/`, with the few acronym-prone file names pinned so a host's `inflect.acronym` declarations cannot change the constants the gem expects.
+
+### Removed
+
+- `RailsPulse.warm_metric_cache!` (a no-op) and `RailsPulse.clear_metric_cache!` (used `delete_matched`, which some cache stores do not support). Neither was referenced by the dashboard.
+
+### Fixed
+
+- **Dashboard pages issue fewer queries.** Tag filtering now runs as subqueries inside each card and chart query instead of plucking every route, query and job id first; the route-backfill check is a single indexed query once every route has an action; and the dashboard's storage headline reuses table sizes for five minutes instead of measuring every table on every load.
+- **Lower per-query capture overhead.** The SQL, template and cache subscribers materialised the whole call stack on every event to find the calling app file; they now walk it lazily and stop at the first app frame, which cuts the per-event cost by half to two thirds on a typical controller stack.
+- **Summary aggregation writes each period in a handful of statements.** Every route, query and job summary used to be found and saved individually, so an hour with a few hundred routes and queries cost over 700 SQL statements; rows are now upserted in bulk against the summaries unique index.
+- **Background tracking no longer spawns a thread per request.** A burst of traffic used to fan out into one writer thread per request, each holding one of the app's database connections, so the app's own request threads could wait seconds for a connection. One writer thread per process now drains a bounded queue on a single connection; when the queue is full the newest request is dropped and counted rather than slowing the app. Adds `config.async_queue_size` (default 1000), `RailsPulse::Tracker.stats`, and an exit hook that drains the queue on restart. SQL normalisation and N+1 detection have moved off the request thread as well.
+- **Metric card sparklines are now correct in time zones east of UTC.** Daily buckets were computed from the stored UTC timestamp, so in zones such as London, Melbourne or Tokyo every card showed each day's value a day early with the latest day at zero, and half-hour zones got empty hourly sparklines. Grouping now follows `config.time_zone`, and the gem no longer adds `group_by_date` / `group_by_hour` to the host's `ActiveRecord::Relation`.
+- **Summary aggregation now runs its transaction on the Rails Pulse connection.** On separate-database installs it was opened on the host's primary database, so a failure part-way through a period could leave partial summaries behind.
+- **The dashboard's own HTTP, mailer, job and storage events are no longer recorded.** These subscribers skipped the recursion guard that SQL and template events already honoured.
+- **Storage page reports real table sizes again.** A leftover screenshot fixture replaced every table's live count, size, and age with hard-coded sample numbers in any environment other than `test`.
+- **Standalone dashboard settings forms no longer fail CSRF verification.** The standalone server (`rails_pulse_server`) used the plain `rack-session` gem's `Rack::Session::Cookie`, which knows nothing about Rails' CSRF handling: a token generated for a form is only written into the session by `commit_csrf_token`, a hook that only Rails' own `ActionDispatch::Session::CookieStore` calls. Every generated token was silently discarded, so every submission failed verification. Switched to `ActionDispatch::Cookies` + `ActionDispatch::Session::CookieStore` (seeding the `action_dispatch.*` env Rails normally sets up before reaching the engine).
+- **Standalone dashboard no longer 404s on the time range and global filters pickers.** Those forms submit `POST` with a hidden `_method=patch` field — the standard verb-override trick — which the mounted engine translates via the host app's default middleware stack. The standalone server (`rails_pulse_server`) builds its own minimal Rack stack and never added `Rack::MethodOverride`, so the request reached routing as a plain `POST` and 404'd against the `PATCH`-only route.
+- **Cleanup no longer risks statement timeouts on large tables.** `CleanupService`'s orphan checks for queries, routes, jobs, and exception groups used a `NOT IN` subquery, which some databases (notably PostgreSQL at scale) execute by materializing and rescanning the full subquery result instead of using an index. Switched to a correlated `NOT EXISTS`, which lets the planner use an index per row. A stalled cleanup stage previously blocked all later stages, including hourly summary pruning. (#253)
+- **Idle periods no longer trigger false "summary job not running" warnings.** `SummaryJob` now records a zero-count overall summary for hours/days with no requests, so the dashboard banner, `rails_pulse:status`, the storage-pressure card, and count-based cleanup no longer mistake "no traffic" for "job stopped running." (#250)
+- **Custom date range charts on the Routes, Queries, and Jobs pages no longer render blank when the server's OS timezone differs from `config.time_zone`.** A custom range was rounded to a day/hour boundary in whatever offset the parsed time happened to carry rather than `Time.zone`, so the boundary could land hours away from where summary data is actually bucketed — every chart series came back all-nil while the metric cards and table (queried differently) kept showing data, which was the visible symptom.
+- **Dashboard charts and metric cards now honor a custom date range instead of always showing the trailing days.** The dashboard collapsed the selected range to a day count and had every chart, card, and sparkline re-derive "the last N days ending now" from it, so a range in the past rendered recent data under the selected range's labels, and the day count itself was truncated by integer division. Charts and cards now bucket the exact selected range.
+- **Custom date range no longer 500s the dashboard on Marshal-backed session stores.** The custom range was written with symbol keys but read back expecting string keys, so stores that preserve symbols (e.g. `activerecord-session_store`) broke every page until the session was cleared; both shapes are now accepted and unreadable preferences fall back to the default range. (#252)
+- **`config.logger` is now honored.** `RailsPulse.logger` previously ignored a custom logger set in the initializer and always wrote to the tagged `Rails.logger`; the configured logger now receives all Rails Pulse log output. (#244)
+- **Cached SQL reads no longer captured as operations.** Query-cache hits were going through the same stack-walk and operation-allocation path as real queries, adding measurable overhead on requests with heavy cache reuse. `config.ignored_queries` now also works — it was previously validated but never consulted when collecting SQL operations.
+- **Dashboard status bar badges are now all clickable.** Routes, Queries, and Jobs badges link to their respective pages, matching Exceptions and Storage.
+- **Standalone auth notice logged once per process.** The "standalone dashboard ignores config.authentication_method / config.authorize" notice kept its once-only flag on each controller class, so it repeated for every engine controller a visitor reached. The flag now lives on `RailsPulse::Standalone` and the notice is logged once per process.
+
 ## [0.4.0.pre.4] - 2026-09-07
 
+### Fixed
+
+- Dependency and packaging fixes only; no user-facing changes beyond 0.4.0.pre.3.
+
 ## [0.4.0.pre.3] - 2026-09-06
 
 ### Added

data/README.md

@@ -1,166 +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
+# config/routes.rb
+mount RailsPulse::Engine => "/rails_pulse"
 ```
 
-Schedule the background jobs:
-
-```ruby
-RailsPulse::SummaryJob.perform_later  # cron: 5 * * * *
-RailsPulse::CleanupJob.perform_later  # cron: 0 1 * * *
+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 * * *"
 ```
 
-Your dashboard is now at `http://localhost:3000/rails_pulse`.
+Open `http://localhost:3000/rails_pulse`. That's the whole setup.
 
-## Upgrading
+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"`.
 
-From 0.3.3:
+Full install guide, including a separate database and plain cron: [railspulse.com/documentation/installation](https://railspulse.com/documentation/installation)
 
-```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.
+## Going further
 
-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.
-
-To see where an install stands at any point — schema, unrun migration files, route backfill, initializer — run `rails rails_pulse:status`. It exits 1 when something needs action, so it can gate a deploy.
-
-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
-```
-
-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`.
-
-Full install guide: [railspulse.com/documentation/installation](https://railspulse.com/documentation/installation)
-
-Separate database setup: [railspulse.com/documentation/database](https://railspulse.com/documentation/database)
-
-## Configuration
-
-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

@@ -86,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
 
@@ -172,11 +174,13 @@ module RailsPulse
       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 if self.class.instance_variable_get(:@_rails_pulse_standalone_auth_noted)
+      return unless RailsPulse.note_host_authentication_ignored!
 
-      self.class.instance_variable_set(:@_rails_pulse_standalone_auth_noted, true)
       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."

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/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/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) {