solid_observer 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a745bb3571f70b207e14f2e88f6162db6b2322a889d42f5ebd2a50e80c5b8014
-  data.tar.gz: d05f835df0503f04f88223c0879145a2dab13279cd5bfc59346545c0e8263f1c
+  metadata.gz: 563c4874ef7e6a8ad8a485d0b3f86c9d1d8f924d5308d44c5137f76bda7e03de
+  data.tar.gz: 88ba3331b45977349604047db1a4e3e98efb17ebc1eca8d4c52a96825d320a83
 SHA512:
-  metadata.gz: 8417c8013a7c9ff03a9d52481af63889adaba093abf0c9b041842664af7fb15edde929f7c7b94c6df12cbac00ca41d2aeee0f488fd7ffe831abf9d5f873bff09
-  data.tar.gz: 92147e32675291ec743e055c55382bf719a9ab6dd10e2e507789d0163b703e06490ad97dbb785e0a9c0b51b8eb72eb7a849d95504ac52c8680e53a137b50e4e4
+  metadata.gz: e56550b5f3cfbbb6a54325901a19bb4a70850a994e047d282cea653b420822cd1a9148c603c2886c92fb5bc9683b650587db575ef90d85b39800430ee7ffbdde
+  data.tar.gz: dbf38ea6c5205ef027642cf02b84e3c59950299ea0477a2f7fef8df7543d71ece58dd90026f396650a99ad948ffa49cf16978f6a596c998d87ab085df739a114

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## [0.5.0] - 2026-06-24
+
+Headline: **Solid Cable observability** — optional Cable telemetry, dashboard, storage health, and guarded trim controls.
+
+### Added
+- **Cable telemetry foundation** (SO-089, SO-090) — `observe_cable` config gate with `solid_cable_available?`/`solid_cable_enabled?` predicates; `CableSubscriber` hooks into `ActiveSupport::Notifications` broadcast events; event/metric buffers reuse `EventBufferCore`; `CableEvent`/`CableMetric` models with two migrations; `cable_sampling_rate` default 0.1; broadcasting names stored as `Digest::SHA256.hexdigest` (PII boundary).
+- **Cable storage health** (SO-091) — Storages page aggregates Solid Cable message storage and SolidObserver Cable telemetry rows with optional fallback states.
+- **Cable dashboard** (SO-092) — `/solid_observer/cable_dashboard` with summary cards, broadcast/rejection trends, stability indicator (hybrid: event + backlog signals), recent events. Three configurable thresholds: `cable_rejection_threshold` (0.05), `cable_backlog_threshold` (0.10), `cable_error_threshold` (0.0). Sidebar navigation entry.
+- **Guarded Cable trim** (SO-093) — UI button for ≤1,000 trimmable messages; `solid_observer:cable:trim` Rake task for larger backlogs. No clear-all.
+
+### Changed
+- **Self-contained SQLite generator config** (SO-094) — install generator produces a `solid_observer_queue` block with explicit `adapter: sqlite3`, `pool`, `timeout`, `database`, and `migrations_paths: db/solid_observer_migrate` — no `<<: *default` YAML merge. Post-install warning printed for PostgreSQL/MySQL hosts. Cable telemetry label standardised to `Cable telemetry`.
+
+## [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,41 @@
 </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.5.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.5.0 covers **Solid Queue**, **Solid Cache**, and **Solid Cable** with a unified Web UI dashboard, CLI tools, metrics collection, and distributed tracing support.
 
-## Features (v0.3.0)
+## Features (v0.5.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 | Solid Cable |
+|---|---|---|---|
+| **Web UI Dashboard** | Queue stats, jobs browser, events log | Hit rate, ops/sec, error rate, avg duration | Broadcasts, rejection rate, trends |
+| **Storage footprint** | DB size, event counts | SolidCache table size, row counts | Message count + backlogs |
+| **Activity trends** | Sparklines (Performed, Ready, Failed) | Activity trend sparklines | Broadcast/rejection sparklines |
+| **Stability indicator** | Stable / Degraded / Critical badge | Stability pill badge | Stable / Degraded / Critical (hybrid) |
+| **Operational controls** | Retry / discard failed jobs | Prune expired entries, clear all entries | Trim expired messages |
+| **CLI tools** | status, jobs:list/show/retry/discard | cache:prune, cache:clear | cable:trim |
+| **Privacy** | Job arguments excluded from persisted events | Keys and values **never** shown | Broadcasting names hashed (SHA256) |
+| **Operating modes** | Real-time (no DB) or persistence (full history) | Persistence mode only | 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)
+- Solid Cache (optional — enable with `config.observe_cache = true`)
+- Solid Cable (optional — enable with `config.observe_cable = true`)
 
 > **Note:** Ensure Solid Queue is configured with `connects_to` in all environments, not just production. See [Troubleshooting](#troubleshooting) if you encounter database connection issues.
 
@@ -71,7 +77,7 @@ That's it. You now have access to queue status, job listing, retry, and discard
 
 Store event history, metrics, and storage snapshots in a dedicated observer database. This gives you everything in real-time mode plus long-term event tracking, buffered writes, and retention-based cleanup. The install generator defaults to SQLite; the database can use any Rails-supported adapter for record persistence, and storage-size monitoring is implemented for SQLite, PostgreSQL/PostGIS, MySQL, and Trilogy. See [Database Setup](#database-setup-persistence-mode) below.
 
-> If your host app uses a different adapter than SQLite (e.g. PostgreSQL or MySQL), see [Multi-adapter setup](#multi-adapter-setup) before running these commands.
+> **⚠️ PostgreSQL / MySQL hosts:** The generator writes a self-contained `solid_observer_queue` block with `adapter: sqlite3`. **Review `config/database.yml` before running `db:create`** — do not merge `<<: *default` into the observer entry, as that pulls the host adapter in and `db:create` will fail. See [Multi-adapter setup](#multi-adapter-setup) for the correct pattern.
 
 ```bash
 bin/rails solid_observer:install:migrations
@@ -169,14 +175,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 +184,19 @@ The install generator mounts it for you. To mount manually:
 mount SolidObserver::Engine, at: "/solid_observer"
 ```
 
-### Configuration
+Production dashboard exposure is the host application's responsibility. If you
+enable and mount the dashboard in production, wrap the mount in your existing
+admin authentication/authorization constraint (example shown for apps that
+already provide an `authenticate` route helper):
+
+```ruby
+# config/routes.rb
+authenticate :user, ->(user) { user.admin? } do
+  mount SolidObserver::Engine, at: "/solid_observer"
+end
+```
+
+### Auth Configuration
 
 ```ruby
 SolidObserver.configure do |config|
@@ -200,43 +210,131 @@ 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`.
+- **HTTP Basic Auth requires both credentials.** Setting only `ui_username` or only `ui_password` disables built-in auth; protect production mounts at the host-app route boundary.
+
+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)
+`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
+```
+
+### Solid Cable Observability
+
+Cable observability is optional. Enable with `config.observe_cable = true`. Requires SolidCable in the host app. SolidObserver does not add any SolidCable dependency.
+
+Cable dashboard (`/solid_observer/cable_dashboard`) shows broadcast/rejection trends, a stability indicator (hybrid: event + backlog signals), and recent safe events. Storages page includes Cable telemetry rows. Guarded trim controls: UI button for ≤1,000 trimmable messages; `solid_observer:cable:trim` Rake task for larger backlogs. **Broadcasting names are stored as SHA256 digests** — raw names are never persisted.
+
+**Enabling Cable observability:**
+
+```ruby
 SolidObserver.configure do |config|
-  if (password = ENV["SOLID_OBSERVER_PASSWORD"]).present?
-    config.ui_username = "admin"
-    config.ui_password = password
-  end
+  config.observe_cable = true  # default: false
+  # config.cable_sampling_rate = 0.1  # Sample 10% of broadcast events (default: 0.1)
+  # config.cable_rejection_threshold = 0.05  # Rejection rate threshold for Degraded (default: 0.05)
+  # config.cable_backlog_threshold = 0.10    # Backlog ratio threshold (default: 0.10)
+  # config.cable_error_threshold = 0.0       # Error rate threshold (default: 0.0)
 end
 ```
 
-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.
+`solid_cable_enabled?` is `true` when both `observe_cable = true` and SolidCable is available in the host app.
 
-### Caveats
+**CLI commands (Solid Cable):**
+
+```bash
+bin/rails solid_observer:cable:trim  # Trim expired Cable messages (with confirmation)
+```
+
+> Cable dashboard screenshots are not yet available — capture from a host app with SolidCable configured.
+
+### Storage
+
+The Storage page aggregates per-component health rows: Queue Observer database, Cache Observer, SolidCache table sizes, and Cable telemetry. Each row reports size, record counts, and a status indicator.
+
+<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 + Cable telemetry" width="700"></a>
+</p>
+
+For adapter notes and multi-adapter setup, see [Database Setup](#database-setup-persistence-mode) below.
+
+### Storage unavailable diagnostics
 
-- **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.
+The dashboard is admin/developer-facing. When SolidObserver storage is not
+reachable, the current default 503 error page includes the raw exception class
+and message so maintainers can diagnose adapter, credential, migration, or
+database availability problems. Do not expose the dashboard to untrusted users.
 
 ## Configuration
 
+<details>
+<summary>Show full configuration reference</summary>
+
 After installation, configure SolidObserver in `config/initializers/solid_observer.rb`:
 
 ```ruby
@@ -249,6 +347,16 @@ 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
+
+  # Enable cable monitoring (default: false; requires SolidCable in host app)
+  config.observe_cable = true
+  config.cable_sampling_rate = 0.1          # Sample 10% of broadcast events
+  config.cable_rejection_threshold = 0.05   # Rejection rate → Degraded stability
+  config.cable_backlog_threshold = 0.10     # Backlog ratio threshold
+  config.cable_error_threshold = 0.0        # Error rate threshold
+
   # 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 +374,6 @@ end
 
 ### APM Integration
 
-Connect SolidObserver with your Application Performance Monitoring tool for distributed tracing:
-
 ```ruby
 SolidObserver.configure do |config|
   # Datadog APM
@@ -294,6 +400,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 +441,11 @@ 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 |
+| `solid_observer:cable:trim` | Trim expired Solid Cable messages |
 
-> **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,57 +459,45 @@ 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)
 solid_observer_queue:
-  <<: *default
   adapter: sqlite3
+  pool: 5
+  timeout: 5000
   database: storage/<%= Rails.env %>_solid_observer_queue.sqlite3
+  migrations_paths: db/solid_observer_migrate
 ```
 
-> **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 produces a self-contained block with explicit `adapter: sqlite3` and `migrations_paths`, which is safe on any host adapter. 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 +505,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 +514,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,21 +522,19 @@ 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.5.0 | Solid Cable monitoring | 🔜 Planned |
+| v0.3.0 | Web UI dashboard + stability hardening | ✅ Released |
+| v0.4.0 | Solid Cache monitoring | ✅ Released |
+| v0.5.0 | Solid Cable monitoring | ✅ Current |
 | v0.6.0 | Cross-component correlation, health scores | 🔜 Planned |
 | v0.7.0 | Alerting & notifications | 🔜 Planned |
 | v1.0.0 | Production stable release | 🎯 Goal |
@@ -478,7 +592,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 +601,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/javascripts/solid_observer/live_poll.js

@@ -10,7 +10,7 @@
   var checkbox, rangeSelect, refreshBtn, helpBtn, helpPanel, helpWrapper, freshnessEl;
   var hoverActive = false;
   var sparks = {};
-  var url = "/solid_observer/poll_data";
+  var url;
   var inFlight = false;
   var timerId = null;
   var lastFullSnapshot = null;
@@ -21,6 +21,8 @@
     var wrapper = document.querySelector("[data-so-live]");
     if (!wrapper) return;
 
+    url = wrapper.getAttribute("data-so-poll-url") || "/solid_observer/poll_data";
+
     checkbox = wrapper.querySelector('[data-so-live-toggle]');
     if (!checkbox) return;
 

data/app/controllers/solid_observer/application_controller.rb

@@ -6,6 +6,7 @@ module SolidObserver
       [
         *([PG::ConnectionBad] if defined?(PG::ConnectionBad)),
         *([Mysql2::Error::ConnectionError] if defined?(Mysql2::Error::ConnectionError)),
+        *([Trilogy::Error] if defined?(Trilogy::Error)),
         *([SQLite3::CantOpenException] if defined?(SQLite3::CantOpenException))
       ]
     end

data/app/controllers/solid_observer/cable_dashboard_controller.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "dashboard_controller"
+
+module SolidObserver
+  # :reek:TooManyInstanceVariables
+  class CableDashboardController < DashboardController
+    CABLE_STORAGE_COMPONENTS = %w[cable_observer solid_cable].freeze
+
+    def index
+      @component = "cable"
+      assign_cable_dashboard
+    end
+
+    private
+
+    # :reek:TooManyStatements
+    def assign_cable_dashboard
+      unless SolidObserver.config.solid_cable_enabled?
+        @cable_dashboard_available = false
+        @storage_components = []
+        @recent_events = []
+        return
+      end
+
+      range = SolidObserver::Services::CableStats.parse_range(request_range_param)
+      window = SolidObserver::Services::CableStats.range_duration(range)
+      stats = SolidObserver::Services::CableStats.call(window: window)
+
+      @cable_dashboard_available = true
+      @range = range
+      @stats = stats
+      @storage_components = cable_storage_components
+      @recent_events = recent_events(window)
+    end
+
+    def cable_storage_components
+      SolidObserver::Services::StorageInfoSnapshot.call.select do |snapshot|
+        CABLE_STORAGE_COMPONENTS.include?(snapshot[:component])
+      end
+    rescue *SolidObserver::Services::StorageInfoSnapshot::CONNECTION_ERRORS, TypeError, NoMethodError
+      []
+    end
+
+    def recent_events(window)
+      current_time = Time.current
+      SolidObserver::CableEvent.where(recorded_at: (current_time - window)..current_time).recent(10)
+    rescue ActiveRecord::StatementInvalid
+      []
+    end
+  end
+end

data/app/controllers/solid_observer/cable_operations_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class CableOperationsController < ApplicationController
+    def trim
+      redirect_with_result(SolidObserver::Services::CableOperations.trim)
+    end
+
+    private
+
+    def redirect_with_result(result)
+      flash_key = result[:ok] ? :notice : :alert
+      redirect_to cable_dashboard_path, flash_key => result[:message]
+    end
+  end
+end