feat(dashboard): complete embedded dashboard telemetry

Author: Tuntii

CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Embedded dashboard snapshots now include request-stage counters, route topology groups, health endpoint summary, and replay admin API discovery metadata.
+- Dashboard UI adds route group/method/tag filters plus a replay browser that reuses the existing `ReplayLayer` admin API for list, detail, and diff workflows.
+- Replay admin list endpoint now accepts UI-friendly pagination and filters: `offset`, `status_max`, `from`, `to`, `tag`, and `order`.
+
+### Documentation
+
+- Added a cookbook recipe and SVG preview for the embedded dashboard and replay browser workflow, including the inspection-first state rewind model and disabled-feature performance budget.
+
 ## [0.1.410] - 2026-03-09
 
 ### Added

api/public/rustapi-rs.all-features.txt

@@ -227,8 +227,19 @@ pub use rustapi_rs::core::serve_dir
 pub use rustapi_rs::core::sse_response
 pub mod rustapi_rs::dashboard
 pub use rustapi_rs::dashboard::DashboardConfig
+pub use rustapi_rs::dashboard::DashboardHealthEndpointSnapshot
+pub use rustapi_rs::dashboard::DashboardHealthSummary
+pub use rustapi_rs::dashboard::DashboardLiveCountersSnapshot
 pub use rustapi_rs::dashboard::DashboardMetrics
+pub use rustapi_rs::dashboard::DashboardReplayIndexSnapshot
 pub use rustapi_rs::dashboard::DashboardSnapshot
+pub use rustapi_rs::dashboard::DashboardStageSnapshot
+pub use rustapi_rs::dashboard::ExecutionPath
+pub use rustapi_rs::dashboard::RequestStage
+pub use rustapi_rs::dashboard::RouteGraphSnapshot
+pub use rustapi_rs::dashboard::RouteGroupSnapshot
+pub use rustapi_rs::dashboard::RouteInventoryItem
+pub use rustapi_rs::dashboard::RouteMetricsSnapshot
 pub mod rustapi_rs::extras
 pub mod rustapi_rs::extras::api_key
 pub use rustapi_rs::extras::api_key::api_key

crates/rustapi-core/src/app.rs

@@ -8,6 +8,8 @@ use crate::response::IntoResponse;
 use crate::router::{MethodRouter, Router};
 use crate::server::Server;
 use std::collections::BTreeMap;
+#[cfg(feature = "dashboard")]
+use std::collections::BTreeSet;
 use std::future::Future;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
 
@@ -1274,18 +1276,42 @@ impl RustApi {
             None => return,
         };
 
-        // Build route inventory from currently registered routes
-        let inventory: Vec<RouteInventoryItem> = self
+        // Build route inventory from currently registered routes. This snapshot
+        // intentionally happens before dashboard routes are mounted so the UI
+        // represents application endpoints rather than the dashboard itself.
+        let mut inventory: Vec<RouteInventoryItem> = self
             .router
             .registered_routes()
             .values()
-            .map(|info| RouteInventoryItem {
-                path: info.path.clone(),
-                methods: info.methods.iter().map(|m| m.to_string()).collect(),
+            .map(|info| {
+                let methods: Vec<String> = info.methods.iter().map(|m| m.to_string()).collect();
+                let health_eligible = self
+                    .health_endpoint_config
+                    .as_ref()
+                    .map(|health| {
+                        info.path == health.health_path
+                            || info.path == health.readiness_path
+                            || info.path == health.liveness_path
+                    })
+                    .unwrap_or(false);
+
+                RouteInventoryItem::new(info.path.clone(), methods)
+                    .with_tags(openapi_tags_for_route(
+                        &self.openapi_spec,
+                        &info.path,
+                        &info.methods,
+                    ))
+                    .with_feature_gates(infer_route_feature_gates(&info.path))
+                    .health_eligible(health_eligible)
+                    .replay_eligible(is_dashboard_replay_eligible(&info.path, health_eligible))
             })
             .collect();
+        inventory.sort_by(|a, b| a.path.cmp(&b.path));
 
-        let metrics = Arc::new(DashboardMetrics::new(inventory));
+        let metrics = Arc::new(DashboardMetrics::new_with_replay_admin_path(
+            inventory,
+            config.replay_api_path.clone(),
+        ));
 
         // Insert metrics into router state using the public .state() API
         let router = std::mem::take(&mut self.router);
@@ -1645,6 +1671,60 @@ impl RustApi {
     }
 }
 
+#[cfg(feature = "dashboard")]
+fn openapi_tags_for_route(
+    spec: &rustapi_openapi::OpenApiSpec,
+    path: &str,
+    methods: &[http::Method],
+) -> Vec<String> {
+    let Some(path_item) = spec.paths.get(path) else {
+        return Vec::new();
+    };
+
+    let mut tags = BTreeSet::new();
+    for method in methods {
+        if let Some(operation) = operation_for_method(path_item, method) {
+            tags.extend(operation.tags.iter().cloned());
+        }
+    }
+
+    tags.into_iter().collect()
+}
+
+#[cfg(feature = "dashboard")]
+fn operation_for_method<'a>(
+    path_item: &'a rustapi_openapi::PathItem,
+    method: &http::Method,
+) -> Option<&'a rustapi_openapi::Operation> {
+    match *method {
+        http::Method::GET => path_item.get.as_ref(),
+        http::Method::POST => path_item.post.as_ref(),
+        http::Method::PUT => path_item.put.as_ref(),
+        http::Method::PATCH => path_item.patch.as_ref(),
+        http::Method::DELETE => path_item.delete.as_ref(),
+        http::Method::HEAD => path_item.head.as_ref(),
+        http::Method::OPTIONS => path_item.options.as_ref(),
+        http::Method::TRACE => path_item.trace.as_ref(),
+        _ => None,
+    }
+}
+
+#[cfg(feature = "dashboard")]
+fn infer_route_feature_gates(path: &str) -> Vec<String> {
+    if path.contains("openapi") || path.contains("docs") {
+        vec!["core-openapi".to_string()]
+    } else if path.starts_with("/__rustapi/replays") {
+        vec!["extras-replay".to_string()]
+    } else {
+        Vec::new()
+    }
+}
+
+#[cfg(feature = "dashboard")]
+fn is_dashboard_replay_eligible(path: &str, health_eligible: bool) -> bool {
+    !health_eligible && !path.starts_with("/__rustapi/")
+}
+
 fn add_path_params_to_operation(
     path: &str,
     op: &mut rustapi_openapi::Operation,

crates/rustapi-core/src/dashboard/config.rs

@@ -10,6 +10,7 @@
 /// let config = DashboardConfig::new()
 ///     .admin_token("my-secret")
 ///     .path("/__rustapi/dashboard")
+///     .replay_api_path("/__rustapi/replays")
 ///     .title("My API Dashboard");
 /// ```
 #[derive(Debug, Clone)]
@@ -23,6 +24,10 @@ pub struct DashboardConfig {
 
     /// Page title shown in the UI.
     pub title: String,
+
+    /// Replay admin API path used by the dashboard replay browser.
+    /// Default: `"/__rustapi/replays"`.
+    pub replay_api_path: String,
 }
 
 impl Default for DashboardConfig {
@@ -38,6 +43,7 @@ impl DashboardConfig {
             admin_token: None,
             path: "/__rustapi/dashboard".to_string(),
             title: "RustAPI System Dashboard".to_string(),
+            replay_api_path: "/__rustapi/replays".to_string(),
         }
     }
 
@@ -63,4 +69,12 @@ impl DashboardConfig {
         self.title = title.into();
         self
     }
+
+    /// Override the replay admin API path used by the UI replay browser.
+    ///
+    /// This should match `ReplayConfig::admin_route_prefix(...)` when replay is enabled.
+    pub fn replay_api_path(mut self, path: impl Into<String>) -> Self {
+        self.replay_api_path = path.into();
+        self
+    }
 }