feat: add benchmark telemetry for all data-loading commands

Log timing for each Tauri command in debug log:
- get_monitors: sidecar call time + total (or cache hit)
- get_dark_mode: sidecar call time (or cache hit)
- get_volume: sidecar call time (or cache hit)
- get_preferences: in-memory lock time
- get_accessibility_trusted: system call time (or cache hit)

All logged as "benchmark: <command> — <ms>" when debug logging is on.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: synle

src-tauri/src/config.rs

@@ -612,12 +612,19 @@ pub fn reset_to_defaults() {
 /// Use `log::info!` instead.
 #[tauri::command]
 pub fn get_preferences(state: tauri::State<'_, crate::AppState>) -> Result<Preferences, String> {
+    let t0 = std::time::Instant::now();
     let prefs = state.preferences.lock().map_err(|e| e.to_string())?;
-    log::info!(
-        "get_preferences: show_contrast={} min_brightness={} monitors={} profiles={}",
-        prefs.show_contrast, prefs.min_brightness, prefs.monitor_configs.len(), prefs.profiles.len()
+    let result = prefs.clone();
+    write_debug_log(
+        &state,
+        &format!(
+            "benchmark: get_preferences — {:.1}ms (in-memory, {} monitors, {} profiles)",
+            t0.elapsed().as_secs_f64() * 1000.0,
+            result.monitor_configs.len(),
+            result.profiles.len(),
+        ),
     );
-    Ok(prefs.clone())
+    Ok(result)
 }
 
 /// Saves updated preferences from the frontend, syncs autostart with the OS, and persists to disk.

src-tauri/src/dark_mode.rs

@@ -18,19 +18,31 @@ fn base_url() -> String {
 pub async fn get_dark_mode(
     state: tauri::State<'_, crate::AppState>,
 ) -> Result<bool, String> {
+    let t0 = std::time::Instant::now();
+
     if let Some(cached) = state.sidecar_cache.get_dark_mode() {
+        crate::config::write_debug_log(
+            &state,
+            &format!("benchmark: get_dark_mode — {:.1}ms (cache hit)", t0.elapsed().as_secs_f64() * 1000.0),
+        );
         return Ok(cached);
     }
 
     let url = format!("{}/theme", base_url());
-    log::info!("get_dark_mode: GET {}", url);
     let resp: ThemeResponse = reqwest::get(&url).await
         .map_err(|e| format!("Failed to get theme: {}", e))?
         .json().await
         .map_err(|e| format!("Failed to parse theme response: {}", e))?;
     let is_dark = resp.theme == "dark";
-    log::info!("get_dark_mode: theme={} is_dark={}", resp.theme, is_dark);
     state.sidecar_cache.set_dark_mode(is_dark);
+
+    crate::config::write_debug_log(
+        &state,
+        &format!(
+            "benchmark: get_dark_mode — {:.1}ms (sidecar, is_dark={})",
+            t0.elapsed().as_secs_f64() * 1000.0, is_dark,
+        ),
+    );
     Ok(is_dark)
 }
 

src-tauri/src/display.rs

@@ -202,12 +202,20 @@ fn ensure_metadata_for_monitors(
 pub async fn get_monitors(
     state: tauri::State<'_, crate::AppState>,
 ) -> Result<Vec<Monitor>, String> {
+    let t0 = std::time::Instant::now();
+
     // Return cached monitors if fresh
     if let Some(cached) = state.sidecar_cache.get_monitors() {
+        crate::config::write_debug_log(
+            &state,
+            &format!("benchmark: get_monitors — {:.1}ms (cache hit)", t0.elapsed().as_secs_f64() * 1000.0),
+        );
         return Ok(cached);
     }
 
     let monitors = detect_monitors().await;
+    let t_sidecar = t0.elapsed();
+
     let mut prefs = state.preferences.lock().map_err(|e| e.to_string())?;
 
     let mut dirty = reconcile_migrated_configs(&monitors, &mut prefs.monitor_configs);
@@ -218,6 +226,16 @@ pub async fn get_monitors(
 
     let result = merge_with_configs(monitors, &prefs.monitor_configs);
     state.sidecar_cache.set_monitors(result.clone());
+
+    crate::config::write_debug_log(
+        &state,
+        &format!(
+            "benchmark: get_monitors — {:.1}ms total (sidecar={:.1}ms, {} monitors)",
+            t0.elapsed().as_secs_f64() * 1000.0,
+            t_sidecar.as_secs_f64() * 1000.0,
+            result.len(),
+        ),
+    );
     Ok(result)
 }
 

src-tauri/src/tiling/mod.rs

@@ -1010,7 +1010,16 @@ pub fn get_tiling_supported() -> bool {
 pub fn get_accessibility_trusted(
     state: tauri::State<'_, crate::AppState>,
 ) -> bool {
+    let t0 = std::time::Instant::now();
+
     if let Some(cached) = state.sidecar_cache.get_accessibility() {
+        crate::config::write_debug_log(
+            &state,
+            &format!(
+                "benchmark: get_accessibility_trusted — {:.1}ms (cache hit, trusted={})",
+                t0.elapsed().as_secs_f64() * 1000.0, cached,
+            ),
+        );
         return cached;
     }
     let result;
@@ -1020,17 +1029,25 @@ pub fn get_accessibility_trusted(
     }
     #[cfg(target_os = "windows")]
     {
-        result = true; // Win32 window management needs no special permissions
+        result = true;
     }
     #[cfg(target_os = "linux")]
     {
-        result = true; // X11 allows any client to manipulate windows
+        result = true;
     }
     #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
     {
         result = false;
     }
     state.sidecar_cache.set_accessibility(result);
+
+    crate::config::write_debug_log(
+        &state,
+        &format!(
+            "benchmark: get_accessibility_trusted — {:.1}ms (system call, trusted={})",
+            t0.elapsed().as_secs_f64() * 1000.0, result,
+        ),
+    );
     result
 }
 

src-tauri/src/volume.rs

@@ -18,18 +18,30 @@ fn base_url() -> String {
 pub async fn get_volume(
     state: tauri::State<'_, crate::AppState>,
 ) -> Result<u32, String> {
+    let t0 = std::time::Instant::now();
+
     if let Some(cached) = state.sidecar_cache.get_volume() {
+        crate::config::write_debug_log(
+            &state,
+            &format!("benchmark: get_volume — {:.1}ms (cache hit)", t0.elapsed().as_secs_f64() * 1000.0),
+        );
         return Ok(cached);
     }
 
     let url = format!("{}/get_volume", base_url());
-    log::info!("get_volume: GET {}", url);
     let resp: VolumeResponse = reqwest::get(&url).await
         .map_err(|e| format!("Failed to get volume: {}", e))?
         .json().await
         .map_err(|e| format!("Failed to parse volume response: {}", e))?;
-    log::info!("get_volume: volume={}", resp.volume);
     state.sidecar_cache.set_volume(resp.volume);
+
+    crate::config::write_debug_log(
+        &state,
+        &format!(
+            "benchmark: get_volume — {:.1}ms (sidecar, volume={})",
+            t0.elapsed().as_secs_f64() * 1000.0, resp.volume,
+        ),
+    );
     Ok(resp.volume)
 }
 

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/nicoverbruggen/tauri-v2-docs/refs/heads/main/schemas/config.schema.json",
   "productName": "Display DJ",
-  "version": "6.3.16",
+  "version": "6.3.17",
   "identifier": "com.synle.display-dj",
   "build": {
     "beforeDevCommand": "npm run dev",