solid_observer 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a745bb3571f70b207e14f2e88f6162db6b2322a889d42f5ebd2a50e80c5b8014
-  data.tar.gz: d05f835df0503f04f88223c0879145a2dab13279cd5bfc59346545c0e8263f1c
+  metadata.gz: a9c3e774c9276371b59f696226979b922772191e0531a4d9ba2dbb09b8e3e452
+  data.tar.gz: 570ae5aacef981358f68998d3df14bfc532e2af48cbdd21c6cd18ecbfa7132e7
 SHA512:
-  metadata.gz: 8417c8013a7c9ff03a9d52481af63889adaba093abf0c9b041842664af7fb15edde929f7c7b94c6df12cbac00ca41d2aeee0f488fd7ffe831abf9d5f873bff09
-  data.tar.gz: 92147e32675291ec743e055c55382bf719a9ab6dd10e2e507789d0163b703e06490ad97dbb785e0a9c0b51b8eb72eb7a849d95504ac52c8680e53a137b50e4e4
+  metadata.gz: 50684bd0b286fc9b93f77a57f5d0b60c3e0334b6d7804bf63307b8cdc05a78cab5bb586305b96617f5fe0e76f76cd89112c6cb6e059a45d190ca6dc7c49fa885
+  data.tar.gz: 9e456400209630d4e3b777355bf1d1a651e0bac1d90d6d40de4272c9cce8afb322bf5ff9afed10fe1a9e0911c7e84c15d02e6b2de3360e04f5d4d349bbf02f34

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [0.4.0] - 2026-06-03
+
+Headline: **Solid Cache observability** — multi-component foundation, cache dashboard, operational controls, and shared storage health.
+
+### Added
+- **Multi-component SolidObserver foundation** (SO-070) — refactored engine, configuration, and storage to support multiple Solid Stack components alongside Solid Queue. Introduced `observe_cache` config flag (default `false`).
+- **Cache telemetry foundation** (SO-071) — `CacheSubscriber` hooks into `ActiveSupport::Notifications` cache events; collects hit/miss/write/delete/prune operations with duration and error tracking. Keys and values are never recorded.
+- **Cache metrics aggregation** (SO-072) — `CacheMetricsAggregator` computes hit rate, operations/sec, error rate, and average duration from raw cache events; scoped to configurable time windows.
+- **Multi-component storage health** (SO-073) — Storage page aggregates Queue Observer DB, Cache Observer, and SolidCache table sizes into unified per-component rows with status indicators.
+- **Cache operational controls** (SO-074) — Cache controls dashboard page; `solid_observer:cache:clear` and `solid_observer:cache:prune` rake tasks; CSRF-protected prune/clear actions in the Web UI.
+- **Cache dashboard** (SO-075) — `/solid_observer/cache_dashboard` — hit rate, ops/sec, error rate, avg duration, storage footprint, activity trend sparklines, and stability pill.
+- **Cache overview activity trends and health parity** (SO-077) — activity trend sparklines on the cache dashboard; stability indicator parity with the Queue dashboard.
+
+### Fixed
+- **SolidCache storage snapshot TypeError** (SO-076) — `StorageInfoSnapshot` raised `TypeError: nil can't be coerced into Integer` on PostgreSQL hosts when SolidCache table names resolved to `nil`. Fixed with a nil-table-name guard on the PG size query path.
+- **Failed-job error payload read as Hash** (SO-079) — `Jobs::Show` raised `NoMethodError` when the serialised `SolidQueue::FailedExecution#error` payload was a plain `Hash` instead of an `ActiveSupport::HashWithIndifferentAccess`. Now reads both representations safely.
+
+### Changed
+- **Cross-tab styling consistency** (SO-078) — unified badge colours, font sizes, and border radii across Queue and Cache dashboard tabs so both surfaces share the same visual language.
+- **Dashboard headers, select heights, and Storage nav** (SO-080) — normalised `<h1>` sizing, select control heights, and Storage navigation link to be consistent across all component tabs; Storage promoted to top-level nav item.
+
 ## [0.3.0] - 2026-05-25
 
 > Note: there is no separate `0.2.0` gem release — work originally scoped for v0.2.0 (stability + refactoring, SO-040 through SO-049) was folded into this release.

data/README.md

@@ -7,35 +7,39 @@
 </p>
 
 <p align="center">
-  <a href="https://github.com/bart-oz/solid_observer/releases"><img src="https://img.shields.io/badge/version-0.3.0-blue.svg" alt="Version"></a>
+  <a href="https://github.com/bart-oz/solid_observer/releases"><img src="https://img.shields.io/badge/version-0.4.0-blue.svg" alt="Version"></a>
   <a href="LICENSE.txt"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
   <a href="https://github.com/bart-oz/solid_observer/actions"><img src="https://img.shields.io/badge/tests-passing-brightgreen.svg" alt="Tests"></a>
-  <a href="https://github.com/bart-oz/solid_observer/actions"><img src="https://img.shields.io/badge/coverage-96.98%25-brightgreen.svg" alt="Coverage"></a>
+  <a href="https://github.com/bart-oz/solid_observer/actions"><img src="https://img.shields.io/badge/coverage-96.22%25-brightgreen.svg" alt="Coverage"></a>
 </p>
 
 ---
 <p align="center">
-  <img src=".github/assets/dash_1.png" alt="Dashboard overview" width="700">
+  <a href=".github/assets/dash_1.png"><img src=".github/assets/dash_1.png" alt="SolidObserver dashboard overview" width="700"></a>
 </p>
 
-SolidObserver is a production-grade observability solution for Rails 8's Solid Stack. Starting with **Solid Queue** monitoring in v0.3.0, it provides unified visibility into your background job processing with a Web UI dashboard, CLI tools, metrics collection, and distributed tracing support.
+SolidObserver is a production-grade observability solution for Rails 8's Solid Stack. v0.4.0 covers both **Solid Queue** and **Solid Cache** with a unified Web UI dashboard, CLI tools, metrics collection, and distributed tracing support.
 
-## Features (v0.3.0)
+## Features (v0.4.0)
 
-- 🖥️ **Web UI Dashboard** — Live queue stats, job browser, event log, and storage info
-- 📊 **Real-time Queue Status** — Monitor jobs across all states (ready, scheduled, claimed, failed)
-- 🔍 **Job Management CLI** — List, inspect, retry, and discard failed jobs
-- 💾 **Storage Monitoring** — Track database size and event counts
-- 🔗 **Distributed Tracing** — Correlate jobs with APM tools (Datadog, Sentry, OpenTelemetry)
-- ⚡ **High Performance** — Buffered writes, configurable sampling, minimal overhead
-- 🛡️ **Production Ready** — Docker/CI/K8s safe boot, automatic cleanup, size limits, retention policies
-- 🚀 **Two Operating Modes** — Real-time (no migrations) or persistence (full event history)
+| | Solid Queue | Solid Cache |
+|---|---|---|
+| **Web UI Dashboard** | Queue stats, jobs browser, events log | Hit rate, ops/sec, error rate, avg duration |
+| **Storage footprint** | DB size, event counts | SolidCache table size, row counts |
+| **Activity trends** | Sparklines (Performed, Ready, Failed) | Activity trend sparklines |
+| **Stability indicator** | Stable / Degraded / Critical badge | Stability pill badge |
+| **Operational controls** | Retry / discard failed jobs | Prune expired entries, clear all entries |
+| **CLI tools** | status, jobs:list/show/retry/discard | cache:prune, cache:clear |
+| **Privacy** | Job arguments excluded from persisted events | Keys and values **never** shown |
+| **Operating modes** | Real-time (no DB) or persistence (full history) | Persistence mode only |
+
+Additional: 🔗 APM distributed tracing · ⚡ buffered writes · 🛡️ Docker/CI/K8s safe boot
 
 ## Requirements
 
 - Ruby 3.2+
 - Rails 8.0+
-- Solid Queue (properly configured for all environments)
+- Solid Queue (configured with `connects_to` in all environments)
 
 > **Note:** Ensure Solid Queue is configured with `connects_to` in all environments, not just production. See [Troubleshooting](#troubleshooting) if you encounter database connection issues.
 
@@ -169,14 +173,6 @@ Configuration:
 
 SolidObserver ships with a zero-dependency Web UI (no asset pipeline, no JS framework) at `/solid_observer`.
 
-<table>
-  <tr>
-    <td align="center"><a href=".github/assets/dash_1.png"><img src=".github/assets/dash_1.png" alt="Dashboard overview" width="250"></a></td>
-    <td align="center"><a href=".github/assets/dash_2.png"><img src=".github/assets/dash_2.png" alt="Dashboard jobs and events" width="250"></a></td>
-    <td align="center"><a href=".github/assets/dash_3.png"><img src=".github/assets/dash_3.png" alt="Dashboard storage and details" width="250"></a></td>
-  </tr>
-</table>
-
 ### Mount
 
 The install generator mounts it for you. To mount manually:
@@ -186,7 +182,7 @@ The install generator mounts it for you. To mount manually:
 mount SolidObserver::Engine, at: "/solid_observer"
 ```
 
-### Configuration
+### Auth Configuration
 
 ```ruby
 SolidObserver.configure do |config|
@@ -200,43 +196,95 @@ end
 | Option | Default | Purpose |
 |---|---|---|
 | `ui_enabled` | `!Rails.env.production?` | Master switch for the Web UI |
-| `ui_username` / `ui_password` | `nil` | HTTP Basic Auth credentials. Auth is enabled only when **both** are set; if either is missing or `nil`, the UI is unauthenticated |
-| `ui_base_controller` | `"ApplicationController"` | Name of your host app's base controller. SolidObserver does **not** inherit from it; the value is used to detect API-only apps so the engine can include the rendering modules its dashboard needs |
+| `ui_username` / `ui_password` | `nil` | HTTP Basic Auth. Auth is enabled only when **both** are set |
+| `ui_base_controller` | `"ApplicationController"` | Detect API-only apps to include rendering modules |
 
-Live polling cadence is hardcoded at 5s.
+For production hardening (fail-loud on missing env var vs. fail-open), see [Configuration](#configuration) below.
 
-### Production hardening (recommended)
+### Caveats
+
+- **Realtime mode** — Events and Storage navigation links are hidden. Direct visits redirect with a flash alert.
+- **API-only apps** — the Web UI works without manual configuration. The engine ships its own Cookies/Session/Flash middleware stack scoped to `/solid_observer/*`.
+- **Host-app callbacks are not inherited.** Use `ui_username` / `ui_password` for built-in HTTP Basic Auth.
+- **Auth misconfiguration is fail-open, but loud.** If `ui_username` is set but `ui_password` resolves to `nil`, the UI ships unauthenticated and logs a boot `WARNING`.
+
+See the full component breakdown in [Components](#components) below.
+
+## Components
+
+### Solid Queue Observability
+
+Live queue stats, job browser (all states: ready/scheduled/claimed/failed), events log, time-range selector (15m → 14d), sparklines for Performed/Ready/Failed, stability indicator, retry/discard with confirmation dialogs. Realtime and persistence modes supported.
+
+<table>
+  <tr>
+    <td align="center"><a href=".github/assets/dash_2.png"><img src=".github/assets/dash_2.png" alt="Queue overview — 1d range" width="340"></a></td>
+    <td align="center"><a href=".github/assets/dash_3.png"><img src=".github/assets/dash_3.png" alt="Jobs list" width="340"></a></td>
+  </tr>
+  <tr>
+    <td align="center"><a href=".github/assets/dash_4.png"><img src=".github/assets/dash_4.png" alt="Failed job detail" width="340"></a></td>
+    <td align="center"><a href=".github/assets/dash_5.png"><img src=".github/assets/dash_5.png" alt="Events stream" width="340"></a></td>
+  </tr>
+</table>
 
-The snippet above silently disables auth if `ENV["SOLID_OBSERVER_PASSWORD"]` is unset (fail-open with a boot warning — see Caveats). For production, prefer one of these patterns so a missing env var fails loudly at boot rather than shipping an unauthenticated UI:
+**CLI commands (Solid Queue):**
+
+```bash
+bin/rails solid_observer:status                                # Queue overview
+bin/rails solid_observer:jobs:list                             # All active jobs
+bin/rails "solid_observer:jobs:list[failed]"                   # Failed jobs
+bin/rails "solid_observer:jobs:show[JOB_ID]"                   # Job details
+bin/rails "solid_observer:jobs:retry[JOB_ID]"                  # Retry failed job
+bin/rails "solid_observer:jobs:discard[JOB_ID]"                # Discard failed job
+bin/rails solid_observer:buffer:flush                          # Flush event buffer
+bin/rails solid_observer:buffer:clear                          # Clear buffer without saving
+```
+
+### Solid Cache Observability
+
+Cache dashboard shows hit rate, operations/sec, error rate, average duration, storage footprint, activity trend sparklines, and a stability pill. Cache controls page provides prune and clear operations. **Keys and values are never shown** — only aggregate metrics are collected.
+
+<table>
+  <tr>
+    <td align="center"><a href=".github/assets/dash_6.png"><img src=".github/assets/dash_6.png" alt="Cache overview dashboard" width="340"></a></td>
+    <td align="center"><a href=".github/assets/dash_7.png"><img src=".github/assets/dash_7.png" alt="Cache operational controls" width="340"></a></td>
+  </tr>
+</table>
+
+**Enabling Cache observability:**
+
+SolidCache must be configured in your host app (Rails 8 default). Then enable in the SolidObserver initializer:
 
 ```ruby
-# Option A: fail at boot if the password env var is missing
 SolidObserver.configure do |config|
-  config.ui_username = "admin"
-  config.ui_password = ENV.fetch("SOLID_OBSERVER_PASSWORD")  # raises KeyError if unset
+  config.observe_cache = true  # default: false
 end
+```
 
-# Option B: only enable auth when the env var is present (no auth otherwise)
-SolidObserver.configure do |config|
-  if (password = ENV["SOLID_OBSERVER_PASSWORD"]).present?
-    config.ui_username = "admin"
-    config.ui_password = password
-  end
-end
+`solid_cache_enabled?` is `true` when both `observe_cache = true` and SolidCache is available in the host app.
+
+**CLI commands (Solid Cache):**
+
+```bash
+bin/rails solid_observer:cache:clear  # Clear all SolidCache entries (with confirmation)
+bin/rails solid_observer:cache:prune  # Prune expired SolidCache entries
 ```
 
-Option A is best when the UI must always be authenticated in production (a missing env var crashes boot — you find out immediately). Option B is best when the UI is optional in some environments.
+### Storage
 
-### Caveats
+The Storage page aggregates per-component health rows: Queue Observer database, Cache Observer, and SolidCache table sizes. Each row reports size, record counts, and a status indicator.
 
-- **Realtime mode** (`storage_mode: :realtime`) — Events and Storage navigation links are hidden. Direct visits to `/solid_observer/events` or `/solid_observer/storage` redirect to the dashboard with a flash alert (`This page is not available in real-time mode`).
-- **API-only apps** — the Web UI works in API-only Rails apps without manual configuration. SolidObserver's engine ships its own Cookies/Session/Flash middleware stack scoped to `/solid_observer/*` requests, so the dashboard renders, flash messages display, and retry/discard CSRF forms work even when the host app has `config.api_only = true`. The host app's middleware stack is not modified.
-- **Custom API base controller** — if your host app's API base controller is **not** named `ApplicationController`, set `config.ui_base_controller` to its name (e.g. `"Api::BaseController"`). The engine uses this only to detect `ActionController::API` ancestry; if detected, it includes `ActionView::Layouts`, `ActionView::Rendering`, and `ActionController::RequestForgeryProtection` so layouts and CSRF forms render.
-- **Host-app callbacks are not inherited.** SolidObserver does not run your host app's `before_action`s or authentication. Use `ui_username` / `ui_password` for the engine's built-in HTTP Basic Auth.
-- **Auth misconfiguration is fail-open, but loud.** If you set `ui_username` but `ui_password` resolves to `nil` (e.g. an unset ENV var), the UI ships unauthenticated rather than locking everyone out — and the engine logs a `WARNING` at boot naming the missing credential. Verify both are set in production.
+<p align="center">
+  <a href=".github/assets/dash_8.png"><img src=".github/assets/dash_8.png" alt="Component health — Queue Observer + Cache Observer + SolidCache" width="700"></a>
+</p>
+
+For adapter notes and multi-adapter setup, see [Database Setup](#database-setup-persistence-mode) below.
 
 ## Configuration
 
+<details>
+<summary>Show full configuration reference</summary>
+
 After installation, configure SolidObserver in `config/initializers/solid_observer.rb`:
 
 ```ruby
@@ -249,6 +297,9 @@ SolidObserver.configure do |config|
   # Enable queue monitoring (default: true)
   config.observe_queue = true
 
+  # Enable cache monitoring (default: false; requires SolidCache in host app)
+  config.observe_cache = true
+
   # Data Retention (persistence mode only)
   config.event_retention = 30.days    # Keep events for 30 days
   config.metrics_retention = 90.days  # Keep metrics for 90 days
@@ -266,8 +317,6 @@ end
 
 ### APM Integration
 
-Connect SolidObserver with your Application Performance Monitoring tool for distributed tracing:
-
 ```ruby
 SolidObserver.configure do |config|
   # Datadog APM
@@ -294,6 +343,26 @@ end
 
 When configured, all job events will include your correlation ID, allowing you to trace jobs back to the originating request.
 
+### Production hardening (recommended)
+
+```ruby
+# Option A: fail at boot if the password env var is missing
+SolidObserver.configure do |config|
+  config.ui_username = "admin"
+  config.ui_password = ENV.fetch("SOLID_OBSERVER_PASSWORD")  # raises KeyError if unset
+end
+
+# Option B: only enable auth when the env var is present (no auth otherwise)
+SolidObserver.configure do |config|
+  if (password = ENV["SOLID_OBSERVER_PASSWORD"]).present?
+    config.ui_username = "admin"
+    config.ui_password = password
+  end
+end
+```
+
+</details>
+
 ## CLI Reference
 
 **Available in both modes (real-time and persistence):**
@@ -315,8 +384,10 @@ When configured, all job events will include your correlation ID, allowing you t
 | `solid_observer:buffer:clear` | Clear buffer without saving |
 | `solid_observer:storage:cleanup` | Run retention-based cleanup |
 | `solid_observer:storage:purge` | Delete ALL SolidObserver data |
+| `solid_observer:cache:clear` | Clear all SolidCache entries (with confirmation) |
+| `solid_observer:cache:prune` | Prune expired SolidCache entries |
 
-> **Note:** Storage commands manage **SolidObserver's storage** (event logs, metrics, snapshots) — not Solid Queue's jobs. To manage jobs, use `jobs:discard` or `jobs:retry`.
+> **Note:** Storage commands manage **SolidObserver's storage** (event logs, metrics, snapshots) — not Solid Queue's jobs. Cache commands operate on SolidCache entries in the host app's cache store.
 
 ### Jobs List Arguments
 
@@ -330,38 +401,24 @@ Arguments are positional: `[status, queue, job_class, limit]`
 | 4th | Max results (default: 20) | `50` |
 
 ```bash
-# Examples
 bin/rails solid_observer:jobs:list                           # All ready jobs
 bin/rails "solid_observer:jobs:list[failed]"                 # Failed jobs
 bin/rails "solid_observer:jobs:list[ready,mailers]"          # Ready jobs in mailers queue
 bin/rails "solid_observer:jobs:list[failed,,,50]"            # 50 failed jobs (skip queue/class)
 ```
 
-### Buffer & Storage Management (Persistence Mode)
-
-```bash
-# Flush in-memory buffer to database
-bin/rails solid_observer:buffer:flush
-
-# Clear buffer without saving (loses pending events!)
-bin/rails solid_observer:buffer:clear
-
-# Run cleanup based on retention policy (default: 30 days)
-bin/rails solid_observer:storage:cleanup
-
-# Delete ALL SolidObserver data (events + snapshots, interactive confirmation)
-bin/rails solid_observer:storage:purge
-```
-
-> **Important:** `storage:purge` deletes SolidObserver's monitoring data, NOT your Solid Queue jobs. Your queued jobs remain safe.
-
 ## Database Setup (Persistence Mode)
 
 > **Tip:** If you're using real-time mode (`storage_mode: :realtime`), you can skip this section entirely — no database setup is needed.
 
 **SolidObserver works with any main application database** — PostgreSQL, MySQL, or SQLite.
 
-For its own monitoring data, the install generator defaults to a **separate SQLite database** — file-based, no extra infrastructure needed. The example below is what `rails generate solid_observer:install` produces:
+For its own monitoring data, the install generator defaults to a **separate SQLite database** — file-based, no extra infrastructure needed.
+
+<details>
+<summary>Show multi-adapter setup and configuration details</summary>
+
+The example below is what `rails generate solid_observer:install` produces:
 
 ```yaml
 # config/database.yml (generator default)
@@ -371,16 +428,16 @@ solid_observer_queue:
   database: storage/<%= Rails.env %>_solid_observer_queue.sqlite3
 ```
 
-> **Note:** SQLite is the generator default, not a requirement. The `solid_observer_queue` database can use any Rails-supported adapter for record persistence. Adapter-native **storage-size monitoring** is currently implemented for SQLite, PostgreSQL/PostGIS, MySQL, and Trilogy. On other adapters, the size query returns `nil` and the engine logs a single `[SolidObserver] Unknown adapter for DatabaseSize: …` warning — record persistence still works, but the size column on the dashboard will be empty until adapter support is added.
+> **Note:** SQLite is the generator default, not a requirement. The `solid_observer_queue` database can use any Rails-supported adapter for record persistence. Adapter-native **storage-size monitoring** is currently implemented for SQLite, PostgreSQL/PostGIS, MySQL, and Trilogy. On other adapters, the size query returns `nil` and the engine logs a single `[SolidObserver] Unknown adapter for DatabaseSize: …` warning — record persistence still works.
 
 ### Multi-adapter setup
 
-If your host application uses one database adapter (e.g. PostgreSQL) and you want SolidObserver to use a different adapter (e.g. SQLite — for isolation, simpler ops, or to avoid loading observability traffic onto your primary DB), keep the `solid_observer_queue` block **self-contained** — do not rely on `<<: *default`. The generator default (shown above) uses `<<: *default` with an explicit `adapter: sqlite3` override; that is safe on SQLite-primary hosts where the anchor is also SQLite. On a PostgreSQL host, merging `<<: *default` without an explicit adapter override pulls the PG adapter into the observer connection and fails at `db:create` with `PG::SyntaxError` (PG treating a SQLite file path as a database name). For multi-adapter connections, omit the merge entirely, as shown below.
+If your host application uses PostgreSQL and you want SolidObserver to use SQLite, keep the `solid_observer_queue` block **self-contained** — do not rely on `<<: *default`. The generator default uses `<<: *default` with an explicit `adapter: sqlite3` override; that is safe on SQLite-primary hosts. On a PostgreSQL host, merging `<<: *default` without an explicit adapter override pulls the PG adapter in and fails at `db:create`. For multi-adapter connections, omit the merge entirely:
 
 ```yaml
 # config/database.yml
 default: &default
-  adapter: postgresql           # host's adapter
+  adapter: postgresql
   encoding: unicode
   pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
 
@@ -388,7 +445,6 @@ development:
   primary:
     <<: *default
     database: my_app_development
-  # ... cache / queue / cable on PG ...
 
   solid_observer_queue:
     adapter: sqlite3            # explicit override — do NOT merge *default
@@ -398,7 +454,7 @@ development:
     migrations_paths: db/solid_observer_migrate
 ```
 
-Apply the same pattern to `test:` and `production:`. For production with SQLite, ensure the `storage/` path is on persistent disk (not ephemeral container storage) — otherwise prefer PostgreSQL for the observer DB too.
+Apply the same pattern to `test:` and `production:`. For production with SQLite, ensure the `storage/` path is on persistent disk.
 
 **Bundler note (PG-only hosts):** if your `Gemfile` does not already include `sqlite3`, add it:
 
@@ -406,20 +462,18 @@ Apply the same pattern to `test:` and `production:`. For production with SQLite,
 gem "sqlite3", "~> 2.0"
 ```
 
-then `bundle install`. SolidObserver does not declare `sqlite3` as a runtime dependency — adapter choice is yours.
+**`migrations_paths` is recommended** to isolate SolidObserver's migrations from the host's primary `db/migrate/` folder. When `migrations_paths` is set on `solid_observer_queue`, `bin/rails solid_observer:install:migrations` copies migrations to that path automatically.
 
-**`migrations_paths` is recommended** to isolate SolidObserver's migrations from the host's primary `db/migrate/` folder. This prevents Rails from running SolidObserver's migrations against your primary database (which would create an unused `solid_observer_queue_events` table there). When `migrations_paths` is set on `solid_observer_queue`, `bin/rails solid_observer:install:migrations` copies migrations to that path automatically — no manual `mv` required.
+</details>
 
 ## Roadmap
 
-SolidObserver is actively developed. Here's what's coming:
-
 | Version | Focus | Status |
 |---------|-------|--------|
 | v0.1.0 | Solid Queue monitoring, CLI tools | ✅ Released |
 | v0.1.1 | Real-time mode (no migrations needed) | ✅ Released |
-| v0.3.0 | Web UI dashboard + stability hardening | ✅ Current |
-| v0.4.0 | Solid Cache monitoring | 🔜 Planned |
+| v0.3.0 | Web UI dashboard + stability hardening | ✅ Released |
+| v0.4.0 | Solid Cache monitoring | ✅ Current |
 | v0.5.0 | Solid Cable monitoring | 🔜 Planned |
 | v0.6.0 | Cross-component correlation, health scores | 🔜 Planned |
 | v0.7.0 | Alerting & notifications | 🔜 Planned |
@@ -478,7 +532,7 @@ config.solid_queue.connects_to = { database: { writing: :queue } }
 
 ### Multi-database setup
 
-> **See also:** [Multi-adapter setup](#multi-adapter-setup) in the Database Setup section for the full pattern (explicit `adapter:` override, `gem "sqlite3"` Bundler note, `migrations_paths` rationale).
+> **See also:** [Multi-adapter setup](#multi-adapter-setup) in the Database Setup section for the full pattern.
 
 SolidObserver works with Rails multi-database configurations. Quick-reference example with PostgreSQL as your primary database and SQLite for SolidObserver's storage:
 
@@ -487,7 +541,6 @@ development:
   primary:
     adapter: postgresql
     database: myapp_development
-    # ... PostgreSQL settings
   solid_observer_queue:
     adapter: sqlite3
     database: storage/development_solid_observer_queue.sqlite3

data/app/assets/stylesheets/solid_observer/application.css

@@ -0,0 +1,18 @@
+.so-sidebar__nav .active {
+  font-weight: 600;
+}
+
+.so-sidebar__nav a:focus-visible {
+  outline: 2px solid var(--so-info);
+  outline-offset: 2px;
+  box-shadow: 0 0 0 3px var(--so-focus-ring);
+}
+
+.so-sidebar__section {
+  font-size: 0.7rem;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: var(--so-text-muted);
+  padding: 0.5rem 0.75rem 0.25rem;
+  margin: 0.5rem 0.75rem 0.25rem;
+}

data/app/controllers/solid_observer/cache_dashboard_controller.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "dashboard_controller"
+
+module SolidObserver
+  class CacheDashboardController < DashboardController
+    CACHE_STORAGE_COMPONENTS = %w[solid_cache cache_observer].freeze
+
+    class << self
+      def cache_dashboard_assignments(range_param:)
+        return unavailable_assignments unless SolidObserver.config.solid_cache_enabled?
+
+        range = SolidObserver::Services::CacheStats.parse_range(range_param)
+        window = SolidObserver::Services::CacheStats.range_duration(range)
+        stats = SolidObserver::Services::CacheStats.call(window: window)
+
+        {
+          cache_dashboard_available: true,
+          range: range,
+          stats: stats,
+          activity_trends: stats[:activity_trends],
+          stability: stats[:stability],
+          storage_components: cache_storage_components,
+          recent_events: recent_events(window)
+        }
+      end
+
+      private
+
+      def unavailable_assignments
+        {
+          cache_dashboard_available: false,
+          storage_components: [],
+          recent_events: [],
+          activity_trends: SolidObserver::Services::CacheStats::ACTIVITY_TREND_EMPTY,
+          stability: SolidObserver::Services::CacheStats::STABILITY_EMPTY
+        }
+      end
+
+      def cache_storage_components
+        SolidObserver::Services::StorageInfoSnapshot.call.select do |snapshot|
+          CACHE_STORAGE_COMPONENTS.include?(snapshot[:component])
+        end
+      end
+
+      def recent_events(window)
+        current_time = Time.current
+        SolidObserver::CacheEvent.where(recorded_at: (current_time - window)..current_time).recent(10)
+      rescue ActiveRecord::StatementInvalid
+        []
+      end
+    end
+
+    def index
+      @component = "cache"
+      assign_cache_dashboard
+    end
+  end
+end

data/app/controllers/solid_observer/cache_operations_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class CacheOperationsController < ApplicationController
+    def index
+      @cache_controls_available = SolidObserver::Services::CacheOperations.available?
+    end
+
+    def prune
+      redirect_with_result(SolidObserver::Services::CacheOperations.prune)
+    end
+
+    def clear
+      redirect_with_result(SolidObserver::Services::CacheOperations.clear)
+    end
+
+    private
+
+    def redirect_with_result(result)
+      flash_key = result[:ok] ? :notice : :alert
+      redirect_to cache_operations_path, flash_key => result[:message]
+    end
+  end
+end

data/app/controllers/solid_observer/dashboard_controller.rb

@@ -1,11 +1,20 @@
 # frozen_string_literal: true
 
+require_relative "../../helpers/solid_observer/application_helper"
+
 module SolidObserver
   class DashboardController < ApplicationController
+    helper SolidObserver::ApplicationHelper
+
     skip_forgery_protection only: :live_poll
     skip_after_action :verify_same_origin_request, only: :live_poll
 
     def index
+      @component = selected_component
+      return assign_cache_dashboard if @component == "cache"
+
+      return unless @component == "queue" && SolidObserver.config.solid_queue_enabled?
+
       assign_range_and_stats
       load_persistence_data if persistence_mode?
     end
@@ -32,13 +41,25 @@ module SolidObserver
       @range = range
       @live = request_live_param == "on"
       @stats = QueueStats.snapshot(range: range)
-      @chart = QueueStats.chart_data(window: QueueStats.range_duration(@range))
+      @chart = if @stats[:available]
+        QueueStats.chart_data(window: QueueStats.range_duration(@range))
+      else
+        {performed: [], failed: [], ready: []}
+      end
+    rescue
+      @chart = {performed: [], failed: [], ready: []}
     end
 
     def load_persistence_data
       @recent_events = QueueEvent.recent(10)
     end
 
+    def assign_cache_dashboard
+      SolidObserver::CacheDashboardController.cache_dashboard_assignments(range_param: request_range_param).each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
     def request_range_param
       request&.query_parameters&.[]("range") || request&.query_parameters&.[](:range)
     end
@@ -75,5 +96,27 @@ module SolidObserver
     def append_chart_buffer
       ChartBuffer.append(SolidQueue::ReadyExecution.count) if QueueStats.solid_queue_available?
     end
+
+    def selected_component
+      requested = if request&.respond_to?(:path_parameters)
+        request.path_parameters&.[](:component).to_s
+      else
+        ""
+      end
+      requested = path_component if requested.empty?
+      return "cache" if requested == "cache" && SolidObserver.config.solid_cache_enabled?
+
+      "queue"
+    end
+
+    def path_component
+      return "" unless request&.respond_to?(:path)
+
+      path = request&.path.to_s
+      return "cache" if path.end_with?("/cache")
+      return "queue" if path.end_with?("/queue")
+
+      ""
+    end
   end
 end

data/app/controllers/solid_observer/storages_controller.rb

@@ -5,7 +5,7 @@ module SolidObserver
     include RequirePersistenceMode
 
     def show
-      @current_storage = SolidObserver::StorageInfo.order(recorded_at: :desc).first
+      @storage_components = SolidObserver::Services::StorageInfoSnapshot.call
       @storage_history = SolidObserver::StorageInfo.recent(20)
     end
   end