feat(monitor): read-back API + UI for deep vitals (CPU/mem/IO/tempdb/plan-cache)

Author: sqlopt

crates/backend/src/routes.rs

@@ -24,6 +24,7 @@ pub fn router() -> Router {
         .route("/health/issue/detail", post(crate::health::enrichment::issue_detail))
         .route("/dmv", post(dmv))
         .route("/monitor/live", post(monitor_live))
+        .route("/monitor/vitals", post(monitor_vitals))
         .route("/explain", post(explain))
         .route("/plan/actual", post(plan_actual))
         .route("/validate", post(validate))
@@ -148,6 +149,19 @@ async fn monitor_live(Json(req): Json<ConnectReq>) -> impl IntoResponse {
     }
 }
 
+/// POST /api/monitor/vitals — the most-recent DEEP-VITALS sample of each
+/// surface (CPU pressure, memory headroom, per-file I/O latency, tempdb
+/// allocation contention, plan-cache health) that the background monitor has
+/// persisted for the connected server.
+///
+/// Read-only: opens the sentinel SQLite store and reads it back — it never
+/// touches the live server. If the store doesn't exist yet, or the server has
+/// never been monitored, it returns 200 with `has_data: false` (an honest empty
+/// state, NOT an error) so the UI can prompt the user to start the monitor.
+async fn monitor_vitals(Json(req): Json<ConnectReq>) -> impl IntoResponse {
+    (StatusCode::OK, Json(sentinel_api::deep_vitals(&req.server))).into_response()
+}
+
 async fn databases(Json(req): Json<ConnectReq>) -> impl IntoResponse {
     match sqlserver::list_databases(&req).await {
         Ok(dbs) => (StatusCode::OK, Json(serde_json::json!({ "databases": dbs }))).into_response(),

crates/backend/src/sentinel_api.rs

@@ -285,6 +285,70 @@ pub fn monitoring_age_secs() -> Option<i64> {
     Storage::open(&path).ok().and_then(|s| s.monitoring_age_secs())
 }
 
+/// Read the most-recent DEEP-VITALS sample of each surface for `server` out of
+/// the sentinel store, shaped for the live UI's "DEEP VITALS" panel.
+///
+/// Honest empty state, never an error: if the store doesn't exist yet, or the
+/// server has never been monitored (no instance row), every surface is `null`
+/// (I/O latency `[]`) and `has_data` is `false`. `captured_at` is the newest
+/// instant across all surfaces present (epoch millis), or `null` when empty —
+/// the UI shows it as "as of …".
+pub fn deep_vitals(server: &str) -> serde_json::Value {
+    let empty = || {
+        serde_json::json!({
+            "has_data": false,
+            "captured_at": serde_json::Value::Null,
+            "cpu_pressure": serde_json::Value::Null,
+            "memory_headroom": serde_json::Value::Null,
+            "io_latency": [],
+            "tempdb_contention": serde_json::Value::Null,
+            "plan_cache": serde_json::Value::Null,
+        })
+    };
+
+    let path = SentinelConfig::default_db_path();
+    let storage = match Storage::open(&path) {
+        Ok(s) => s,
+        Err(_) => return empty(), // store not created yet → not an error
+    };
+    let Some(instance_id) = storage.get_instance_id(server) else {
+        return empty(); // server never monitored → not an error
+    };
+
+    let cpu = storage.latest_cpu_pressure(instance_id);
+    let mem = storage.latest_memory_headroom(instance_id);
+    let io = storage.latest_io_latency(instance_id);
+    let tempdb = storage.latest_tempdb_contention(instance_id);
+    let plan = storage.latest_plan_cache(instance_id);
+
+    // Newest captured_at across whichever surfaces have data (millis).
+    let captured_at_ms = [
+        cpu.as_ref().map(|r| r.captured_at.timestamp_millis()),
+        mem.as_ref().map(|r| r.captured_at.timestamp_millis()),
+        io.first().map(|r| r.captured_at.timestamp_millis()),
+        tempdb.as_ref().map(|r| r.captured_at.timestamp_millis()),
+        plan.as_ref().map(|r| r.captured_at.timestamp_millis()),
+    ]
+    .into_iter()
+    .flatten()
+    .max();
+
+    let has_data =
+        cpu.is_some() || mem.is_some() || !io.is_empty() || tempdb.is_some() || plan.is_some();
+
+    // The row structs derive Serialize, so each maps straight to JSON; the field
+    // names match the storage row structs (snake_case), which the UI consumes.
+    serde_json::json!({
+        "has_data": has_data,
+        "captured_at": captured_at_ms,
+        "cpu_pressure": cpu,
+        "memory_headroom": mem,
+        "io_latency": io,
+        "tempdb_contention": tempdb,
+        "plan_cache": plan,
+    })
+}
+
 pub fn build_report(window: TimeRange) -> WeeklyReport {
     let path = SentinelConfig::default_db_path();
     match Storage::open(&path) {

crates/sentinel/src/poll/mod.rs

@@ -1,6 +1,11 @@
 //! Per-surface pollers. Each submodule exposes a single async `poll_*`
-//! function that the scheduler invokes on its cadence. Bodies are stubs
-//! today — next session swaps in the real `tiberius` queries.
+//! function that the scheduler invokes on its cadence. Each one runs a real
+//! read-only `tiberius` query against the live server's DMVs, maps the result
+//! into the matching `storage` row struct, and persists it (the cumulative
+//! surfaces — waits, index usage, file I/O — diff against the prior snapshot
+//! held in `poller_state` to emit per-window deltas). Pollers degrade
+//! gracefully: a missing DMV or a lack of VIEW SERVER STATE logs once and skips
+//! the tick rather than failing the whole daemon.
 
 pub mod cpu_pressure;
 pub mod deadlocks;