perf: cached header/status-bar info, 500ms API timeout, zero per-frame format!()

Mana (마나) · claude · Mana (마나) · commit e9b8bc7d8ac5 · 2026-03-17T11:26:39.000+09:00
- Cache HeaderInfo struct (cluster name, endpoint, k8s ver, config path)
  via sync_header_info() — eliminates O(n) clusters.iter().find() per frame
- Pre-compute status_bar_self_line on fetch arrival — eliminates per-frame
  format!() for RSS/latency display
- Pre-compute NodeInfo.top_display during fetch — eliminates per-node
  format!() per frame in Top tab
- Cache ctx_title_span on cluster/namespace change — eliminates per-frame
  format!("| {} ", ctx_label) in center panel title
- Static render_usage_bar label spans — eliminates 2 format!() per bar
- Reduce API_CALL_TIMEOUT from 1s to 500ms — halves worst-case fetch latency
- Fix headless run_headless() to use join_all instead of sequential await

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -107,7 +107,7 @@ scalex dash --headless --resource pods   # Filter by resource type (pods, nodes,
 - **Node VERSION column**: `NodeInfo.kubelet_version` populated from `node.status.nodeInfo.kubeletVersion`. Shown in nodes table after ROLES column and in Top tab after node name. Useful for upgrade planning.
 - **Service EXTERNAL-IP column**: `ServiceInfo.external_ip` populated from `status.loadBalancer.ingress[].ip/hostname`. Shows `<none>` for non-LB services. Column appears between CLUSTER-IP and PORTS.
 - **Alphabetical resource sorting**: Deployments, services, configmaps, and nodes sorted by name after fetch. Pods retain severity-first sorting (CrashLoopBackOff first, then pending, running, completed).
-- **Reduced API timeouts**: `API_CALL_TIMEOUT` reduced from 2s to 1s, `DISCOVER_TIMEOUT` from 3s to 2s. Healthy clusters respond in <200ms; tighter timeouts halve worst-case fetch latency.
+- **Reduced API timeouts**: `API_CALL_TIMEOUT` reduced from 2s to 500ms, `DISCOVER_TIMEOUT` from 3s to 2s. Healthy clusters respond in <200ms; tighter timeouts minimize worst-case fetch latency.
 - **Zero-clone tree index lookups**: `tree_index_at_cursor()` reads from cached visible indices without cloning `Vec<usize>`. `ensure_visible_indices_cached()` populates cache; callers avoid `visible_tree_indices_cached()` clone where possible.
 - **Static sidebar padding**: `render_sidebar` uses static `SPACES` buffer for row padding instead of per-row `" ".repeat(pad)` heap allocation.
 - **Cached row count**: `cached_row_count: Option<usize>` avoids redundant O(n) filter iterations in `move_down`/`page_down`/`jump_end`/`render_center`. Invalidated per event cycle.
@@ -183,6 +183,12 @@ The TUI header is k9s-style and responsive:
 - **CF Tunnel SA token auth**: CF Tunnel cannot proxy mTLS client certs, so `build_client_with_endpoint()` strips kubeconfig CA + client cert and injects a ServiceAccount bearer token. SA `scalex-dash` in `scalex-system` namespace, bound to `view` ClusterRole. Token cached at `_generated/clusters/{name}/dash-token`. Auto-provisioned on first run via SSH through bastion if cached token absent. Module: `sa_provisioner.rs`. To re-provision: delete `dash-token` and relaunch.
 - **k9s attribution**: help overlay (`?` key) footer shows "Inspired by k9s (github.com/derailed/k9s)" in DarkGray.
 - **Cached data persistence**: `render_tab_preamble` returns cached snapshot even when `ConnectionStatus::Failed` — error shown as 1-line red banner via `render_connection_error_banner()`, not full-area replacement. Data stability: once displayed, data stays visible until next fetch result arrives.
+- **Cached header info**: `HeaderInfo` struct (cluster_name, endpoint, k8s_version, config_path) pre-computed via `sync_header_info()` on cluster selection change and discovery events. `render_header` reads cached struct instead of O(n) `clusters.iter().find()` + `display().to_string()` per frame.
+- **Pre-computed status bar self/latency**: `status_bar_self_line` caches `"| self: 42MB | latency: 150ms"` on fetch result arrival. Spinner appended dynamically only when fetching. Eliminates per-frame `format!()` for rss + latency.
+- **Pre-computed top tab node display**: `NodeInfo.top_display` pre-computed during fetch as `"  v1.33.1  CPU: 8/8  MEM: 7.5Gi/7.8Gi"`. `render_top_tab` borrows pre-computed string instead of per-node `format!()` per frame.
+- **Cached center panel title**: `ctx_title_span` pre-computed on cluster/namespace change via `sync_ctx_label()`. `render_center` borrows cached string instead of per-frame `format!("| {} ", ctx_label)`.
+- **Static usage bar labels**: `render_usage_bar` uses static `label` + `" ["` spans instead of `format!("{} [", label)`. Eliminates 2 format allocations per bar per frame.
+- **Headless parallel fetch**: `run_headless` uses `futures::future::join_all` instead of sequential `for handle in handles { handle.await }` for cluster data fetching.
 - **Per-resource fetch tracking**: `fetched_resources: HashSet<ActiveResource>` distinguishes "not yet fetched" (empty vec, not in set) from "fetched but truly empty" (empty vec, in set). Cleared on cluster/namespace change. View switch to unfetched resource shows "Loading {type}..." spinner instead of empty table.
 
 ## Key Patterns
diff --git a/scalex-cli/src/dash/app.rs b/scalex-cli/src/dash/app.rs
@@ -102,6 +102,31 @@ pub enum NodeType {
     InfraItem(String),
 }
 
+// ---------------------------------------------------------------------------
+// Cached header info
+// ---------------------------------------------------------------------------
+
+/// Pre-computed header info to avoid O(n) cluster search per frame.
+/// Updated via sync_header_info() on cluster selection or discovery events.
+#[derive(Debug, Clone)]
+pub struct HeaderInfo {
+    pub cluster_name: String,
+    pub endpoint: String,
+    pub k8s_version: String,
+    pub config_path: String,
+}
+
+impl Default for HeaderInfo {
+    fn default() -> Self {
+        Self {
+            cluster_name: "--".to_string(),
+            endpoint: "--".to_string(),
+            k8s_version: "N/A".to_string(),
+            config_path: "--".to_string(),
+        }
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Connection status for per-cluster discovery tracking
 // ---------------------------------------------------------------------------
@@ -246,6 +271,9 @@ pub struct App {
     /// Eliminates per-frame `format!()` in render_center.
     pub ctx_label: String,
 
+    /// Pre-computed "| context_label " for center panel title. Updated on cluster/namespace change.
+    pub ctx_title_span: String,
+
     /// Cached row count for current resource view + search filter.
     /// Invalidated (None) on: data change, view switch, search change, cluster/namespace change.
     /// Avoids redundant O(n) filter iteration in move_down/page_down/jump_end/render_center.
@@ -254,6 +282,14 @@ pub struct App {
     /// Pre-computed status bar health strings per cluster. Updated on fetch result arrival.
     /// Eliminates per-frame format!() for pod/node counts in render_status_bar.
     pub status_bar_health_strings: Vec<(String, String)>, // (narrow_str, wide_str) per snapshot
+
+    /// Pre-computed "| self: 42MB | latency: 150ms" for status bar.
+    /// Updated on fetch result arrival. Spinner appended dynamically in render.
+    pub status_bar_self_line: String,
+
+    /// Pre-computed header info (cluster name, endpoint, k8s version, config path).
+    /// Updated via sync_header_info() on cluster selection or discovery events.
+    pub header_info: HeaderInfo,
 }
 
 /// ASCII case-insensitive substring search without allocation.
@@ -368,8 +404,11 @@ impl App {
             needs_redraw: true,
             render_visible_indices: Vec::new(),
             ctx_label: "No cluster selected".to_string(),
+            ctx_title_span: "| No cluster selected ".to_string(),
             cached_row_count: None,
             status_bar_health_strings: Vec::new(),
+            status_bar_self_line: "| self: N/A | latency: 0ms".to_string(),
+            header_info: HeaderInfo::default(),
         }
     }
 
@@ -463,8 +502,11 @@ impl App {
             needs_redraw: true,
             render_visible_indices: Vec::new(),
             ctx_label: "No cluster selected".to_string(),
+            ctx_title_span: "| No cluster selected ".to_string(),
             cached_row_count: None,
             status_bar_health_strings: Vec::new(),
+            status_bar_self_line: "| self: N/A | latency: 0ms".to_string(),
+            header_info: HeaderInfo::default(),
         }
     }
 
@@ -726,6 +768,26 @@ impl App {
             (Some(c), None) => format!("{} > All Namespaces", c),
             _ => "No cluster selected".to_string(),
         };
+        self.ctx_title_span = format!("| {} ", self.ctx_label);
+    }
+
+    /// Sync cached header info. Called on cluster selection change and discovery events.
+    pub fn sync_header_info(&mut self) {
+        let selected = self
+            .selected_cluster
+            .as_ref()
+            .and_then(|name| self.clusters.iter().find(|c| &c.name == name))
+            .or_else(|| self.clusters.first());
+
+        self.header_info = match selected {
+            Some(c) => HeaderInfo {
+                cluster_name: c.name.clone(),
+                endpoint: c.endpoint.as_deref().unwrap_or("--").to_string(),
+                k8s_version: c.server_version.as_deref().unwrap_or("N/A").to_string(),
+                config_path: c.kubeconfig_path.display().to_string(),
+            },
+            None => HeaderInfo::default(),
+        };
     }
 
     /// Sync the pre-lowercased search query cache. Called once per event cycle.
@@ -1014,6 +1076,7 @@ impl App {
                     self.is_fetching = false;
                     self.fetched_resources.clear();
                     self.sync_ctx_label();
+                    self.sync_header_info();
                     // Immediately populate tree from cached snapshots
                     self.sync_tree_from_snapshots();
                 }
@@ -1030,6 +1093,7 @@ impl App {
                 self.table_cursor = 0;
                 self.table_scroll_offset = 0;
                 self.sync_ctx_label();
+                self.sync_header_info();
                 self.needs_refresh = true;
                 self.refresh_selected_only = true;
                 self.fetch_generation += 1;
@@ -1544,6 +1608,16 @@ impl App {
                 (narrow, wide)
             })
             .collect();
+
+        // Pre-compute self/latency line (changes only on fetch result arrival)
+        let rss_str = self
+            .self_rss_mb
+            .map(|mb| format!("{:.0}MB", mb))
+            .unwrap_or_else(|| "N/A".into());
+        self.status_bar_self_line = format!(
+            "| self: {} | latency: {}ms",
+            rss_str, self.api_latency_ms
+        );
     }
 
     pub fn current_snapshot(&self) -> Option<&ClusterSnapshot> {
@@ -1682,8 +1756,11 @@ mod tests {
             needs_redraw: true,
             render_visible_indices: Vec::new(),
             ctx_label: "No cluster selected".to_string(),
+            ctx_title_span: "| No cluster selected ".to_string(),
             cached_row_count: None,
             status_bar_health_strings: Vec::new(),
+            status_bar_self_line: "| self: N/A | latency: 0ms".to_string(),
+            header_info: HeaderInfo::default(),
         };
         // Move cursor to first cluster (tower)
         app.tree_cursor = 1;
@@ -3836,6 +3913,7 @@ pub async fn run_tui(args: DashArgs, kubeconfig_dir: PathBuf) -> Result<()> {
                     app.cluster_connection_status
                         .insert(name.clone(), ConnectionStatus::Connected);
                     app.clusters.push(client);
+                    app.sync_header_info();
                     // Auto-select first connected cluster if none selected
                     if app.selected_cluster.is_none() {
                         app.selected_cluster = Some(name.clone());
@@ -3928,6 +4006,7 @@ pub async fn run_tui(args: DashArgs, kubeconfig_dir: PathBuf) -> Result<()> {
             app.fetched_resources.insert(ActiveResource::Nodes);
             app.sync_tree_from_snapshots();
             app.sync_status_bar_strings();
+            app.sync_header_info();
             app.self_rss_mb = result.self_rss_mb;
             // Apply infra data loaded on worker thread
             if let Some(infra_snap) = result.infra {
diff --git a/scalex-cli/src/dash/data.rs b/scalex-cli/src/dash/data.rs
@@ -19,9 +19,9 @@ pub enum ActiveResource {
 }
 
 /// Per-API-call timeout to prevent slow calls from blocking the entire fetch.
-/// Reduced from 2s to 1s — K8s API calls on a healthy cluster complete in <200ms;
-/// 1s is generous while halving worst-case fetch latency.
-const API_CALL_TIMEOUT: Duration = Duration::from_secs(1);
+/// Reduced from 1s to 500ms — K8s API calls on a healthy cluster complete in <200ms;
+/// 500ms is generous while halving worst-case fetch latency.
+const API_CALL_TIMEOUT: Duration = Duration::from_millis(500);
 
 // ---------------------------------------------------------------------------
 // Data models
@@ -69,6 +69,8 @@ pub struct NodeInfo {
     pub mem_display: String,
     /// Kubelet version (e.g., "v1.33.1") from node.status.nodeInfo
     pub kubelet_version: String,
+    /// Pre-computed display string for Top tab: "  v1.33.1  CPU: 8/8  MEM: 7.5Gi/7.8Gi"
+    pub top_display: String,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -312,6 +314,11 @@ pub async fn fetch_nodes(client: &Client) -> Result<Vec<NodeInfo>> {
                 .map(|ni| ni.kubelet_version.clone())
                 .unwrap_or_default();
 
+            let top_display = format!(
+                "  {}  CPU: {}  MEM: {}",
+                kubelet_version, cpu_display, mem_display
+            );
+
             NodeInfo {
                 name: meta.name.clone().unwrap_or_default(),
                 status: node_status,
@@ -327,6 +334,7 @@ pub async fn fetch_nodes(client: &Client) -> Result<Vec<NodeInfo>> {
                 cpu_display,
                 mem_display,
                 kubelet_version,
+                top_display,
             }
         })
         .collect())
diff --git a/scalex-cli/src/dash/mod.rs b/scalex-cli/src/dash/mod.rs
@@ -70,9 +70,10 @@ pub mod headless {
                 data::fetch_cluster_snapshot(&client, &name, ns.as_deref(), None).await
             }));
         }
+        let results = futures::future::join_all(handles).await;
         let mut cluster_data = Vec::new();
-        for handle in handles {
-            if let Ok(Ok(snapshot)) = handle.await {
+        for result in results {
+            if let Ok(Ok(snapshot)) = result {
                 cluster_data.push(snapshot);
             }
         }
diff --git a/scalex-cli/src/dash/ui.rs b/scalex-cli/src/dash/ui.rs
@@ -88,21 +88,12 @@ const LOGO: [&str; 6] = [
 fn render_header(f: &mut Frame, app: &App, area: Rect) {
     let is_full = area.height >= 8;
 
-    // Gather cluster info for the selected (or first) cluster
-    let selected = app
-        .selected_cluster
-        .as_ref()
-        .and_then(|name| app.clusters.iter().find(|c| &c.name == name))
-        .or_else(|| app.clusters.first());
-
-    let cluster_name = selected.map(|c| c.name.as_str()).unwrap_or("--");
-    let endpoint_str = selected.and_then(|c| c.endpoint.as_deref()).unwrap_or("--");
-    let k8s_ver = selected
-        .and_then(|c| c.server_version.as_deref())
-        .unwrap_or("N/A");
-    let config_path = selected
-        .map(|c| c.kubeconfig_path.display().to_string())
-        .unwrap_or_else(|| "--".into());
+    // Use pre-computed header info (O(1) instead of O(n) cluster search per frame)
+    let hi = &app.header_info;
+    let cluster_name = hi.cluster_name.as_str();
+    let endpoint_str = hi.endpoint.as_str();
+    let k8s_ver = hi.k8s_version.as_str();
+    let config_path = &hi.config_path;
 
     let scalex_ver = env!("CARGO_PKG_VERSION");
 
@@ -124,7 +115,7 @@ fn render_header(f: &mut Frame, app: &App, area: Rect) {
             cluster_name,
             endpoint_str,
             k8s_ver,
-            &config_path,
+            config_path,
             scalex_ver,
             total_clusters,
             connected_clusters,
@@ -544,8 +535,6 @@ fn render_center(f: &mut Frame, app: &App, area: Rect) {
         theme::BG3
     };
 
-    let ctx_label = &app.ctx_label;
-
     // Resource shortcut indicator: p d s c n with active one highlighted
     // Static strings avoid per-frame format!() allocation for tab labels
     const SHORTCUTS_ACTIVE: [&str; 5] = ["[p]Pods ", "[d]Deploy ", "[s]Svc ", "[c]CM ", "[n]Nodes "];
@@ -612,7 +601,7 @@ fn render_center(f: &mut Frame, app: &App, area: Rect) {
         }
     }
     title_spans.push(Span::styled(
-        format!("| {} ", ctx_label),
+        app.ctx_title_span.as_str(),
         Style::default().fg(theme::FG),
     ));
     let block = Block::default()
@@ -1211,10 +1200,7 @@ fn render_top_tab(f: &mut Frame, app: &App, area: Rect) {
                 Style::default().fg(theme::FG).add_modifier(Modifier::BOLD),
             ),
             Span::styled(
-                format!(
-                    "  {}  CPU: {}  MEM: {}",
-                    node.kubelet_version, node.cpu_display, node.mem_display
-                ),
+                node.top_display.as_str(),
                 Style::default().fg(theme::FG3),
             ),
         ]));
@@ -1253,8 +1239,8 @@ const BAR_EMPTY: &str = "--------------------"; // 20 chars max
 fn render_usage_bar<'a>(label: &'a str, percent: f64, width: usize, color: Color) -> Vec<Span<'a>> {
     if percent < 0.0 {
         return vec![
-            Span::styled(format!("{} ", label), Style::default().fg(theme::FG4)),
-            Span::styled("N/A ", Style::default().fg(theme::FG4)),
+            Span::styled(label, Style::default().fg(theme::FG4)),
+            Span::styled(" N/A ", Style::default().fg(theme::FG4)),
         ];
     }
     let width = width.min(BAR_FILL.len());
@@ -1270,7 +1256,8 @@ fn render_usage_bar<'a>(label: &'a str, percent: f64, width: usize, color: Color
     };
 
     vec![
-        Span::styled(format!("{} [", label), Style::default().fg(theme::FG4)),
+        Span::styled(label, Style::default().fg(theme::FG4)),
+        Span::styled(" [", Style::default().fg(theme::FG4)),
         Span::styled(&BAR_FILL[..filled], Style::default().fg(bar_color)),
         Span::styled(&BAR_EMPTY[..empty], Style::default().fg(theme::FG4)),
         Span::styled(
@@ -1344,15 +1331,7 @@ fn render_status_bar(f: &mut Frame, app: &App, area: Rect) {
     let very_narrow = inner.width < 60;
 
     // Self overhead + fetch indicator (always shown)
-    let rss_str = app
-        .self_rss_mb
-        .map(|mb| format!("{:.0}MB", mb))
-        .unwrap_or_else(|| "N/A".into());
-    let fetch_indicator = if app.is_fetching {
-        format!(" {} ", spinner)
-    } else {
-        String::new()
-    };
+    // rss_str and latency are pre-computed in status_bar_self_line; spinner appended dynamically
 
     if !very_narrow {
         let bar_width = if narrow { 5 } else { 8 };
@@ -1377,13 +1356,17 @@ fn render_status_bar(f: &mut Frame, app: &App, area: Rect) {
         }
     }
 
+    // Pre-computed self/latency base string; append spinner dynamically if fetching
     usage_spans.push(Span::styled(
-        format!(
-            "| self: {} | latency: {}ms{}",
-            rss_str, app.api_latency_ms, fetch_indicator
-        ),
+        app.status_bar_self_line.as_str(),
         Style::default().fg(theme::BRIGHT_AQUA),
     ));
+    if app.is_fetching {
+        usage_spans.push(Span::styled(
+            format!(" {} ", spinner),
+            Style::default().fg(theme::BRIGHT_AQUA),
+        ));
+    }
     if app.fetch_timed_out {
         usage_spans.push(Span::styled(
             " [!] fetch timed out — press 'r' to retry",

Original file line number	Diff line number	Diff line change
`@@ -70,9 +70,10 @@ pub mod headless {`
`70`	`70`	`data::fetch_cluster_snapshot(&client, &name, ns.as_deref(), None).await`
`71`	`71`	`}));`
`72`	`72`	`}`
	`73`	`+ let results = futures::future::join_all(handles).await;`
`73`	`74`	`let mut cluster_data = Vec::new();`
`74`		`- for handle in handles {`
`75`		`- if let Ok(Ok(snapshot)) = handle.await {`
	`75`	`+ for result in results {`
	`76`	`+ if let Ok(Ok(snapshot)) = result {`
`76`	`77`	`cluster_data.push(snapshot);`
`77`	`78`	`}`
`78`	`79`	`}`