tauri_plugin_widgets/

trace.rs

//! Host-side black-box journal for widget delivery diagnostics.
//!
//! Enabled in debug builds, or in release when `WIDGET_DEBUG=1`.
//! Events stay in a memory ring (cap 200); disk flush is never per-event —
//! only on timer / explicit `get_widget_trace` / `flush_widget_trace`.

use serde::{Deserialize, Serialize};
use std::collections::VecDeque;
use std::env;
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Mutex;
use std::time::{Duration, Instant};

use crate::apply::{ReloadOutcome, SkipReason};
use crate::store::now_ms;

const RING_CAP: usize = 200;
const FLUSH_INTERVAL: Duration = Duration::from_secs(10);
/// On-disk journal filename under the widgets data dir.
pub const TRACE_FILE_NAME: &str = "widget_trace.json";

/// Whether the in-memory / disk journal is active.
pub fn trace_enabled() -> bool {
    if cfg!(debug_assertions) {
        return true;
    }
    matches!(
        env::var("WIDGET_DEBUG").ok().as_deref(),
        Some("1") | Some("true") | Some("TRUE")
    )
}

/// One journal entry.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(
    tag = "kind",
    rename_all = "camelCase",
    rename_all_fields = "camelCase"
)]
pub enum TraceEvent {
    /// Host applied (or skipped) a config write.
    ConfigSet {
        /// Widget id.
        widget_id: String,
        /// Map nonce after the write attempt.
        nonce: u64,
        /// Serialized config size.
        bytes: usize,
        /// `true` when store bytes changed.
        changed: bool,
        /// Present when the write was skipped.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        skip: Option<SkipReason>,
    },
    /// A transport `write` finished.
    Write {
        /// Driver name.
        transport: String,
        /// Success flag.
        ok: bool,
        /// Wall time of the write.
        duration_ms: u32,
        /// Error text when `ok` is false.
        #[serde(default, skip_serializing_if = "Option::is_none")]
        error: Option<String>,
    },
    /// Native / WidgetKit reload attempt.
    Reload {
        /// Whether reload was invoked.
        performed: bool,
        /// Outcome detail.
        reason: ReloadOutcome,
    },
    /// Host drained pending actions.
    Poll {
        /// Actions returned this poll.
        count: usize,
    },
    /// Native / desktop surface painted.
    Render {
        /// Instance id (family / appWidgetId / window).
        instance: String,
        /// Config nonce observed.
        nonce: u64,
        /// Transport / prefs source label.
        source: String,
        /// Why paint ran (`reload`, `timeline`, …).
        trigger: String,
        /// Host write → paint lag.
        lag_ms: u64,
        /// Elements skipped this paint.
        skipped: Vec<crate::receipt::SkippedElement>,
    },
}

/// Timestamped [`TraceEvent`] in the ring.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TraceEntry {
    /// Unix ms.
    pub ts: u64,
    /// Event payload (flattened in JSON).
    #[serde(flatten)]
    pub event: TraceEvent,
}

/// Snapshot returned by `get_widget_trace`.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WidgetTrace {
    /// Whether journaling is active in this process.
    pub enabled: bool,
    /// Ring buffer contents (oldest → newest).
    pub events: Vec<TraceEntry>,
    /// Latest receipts from the companion store.
    pub receipts: Vec<crate::receipt::WidgetRenderReceipt>,
}

#[derive(Default)]
struct TraceInner {
    events: VecDeque<TraceEntry>,
    dirty: bool,
    last_flush: Option<Instant>,
}

/// Process-wide style store held on [`crate::desktop::Widget`] / mobile.
#[derive(Default)]
pub struct TraceStore {
    inner: Mutex<TraceInner>,
    flush_started: AtomicBool,
}

impl TraceStore {
    /// Empty store.
    pub fn new() -> Self {
        Self::default()
    }

    /// Append an event when tracing is enabled.
    pub fn push(&self, event: TraceEvent) {
        if !trace_enabled() {
            return;
        }
        let mut g = self.inner.lock().unwrap();
        g.events.push_back(TraceEntry {
            ts: now_ms(),
            event,
        });
        while g.events.len() > RING_CAP {
            g.events.pop_front();
        }
        g.dirty = true;
    }

    /// Events with `ts >= since_ms` (or all when `None`).
    pub fn list_since(&self, since_ms: Option<u64>) -> Vec<TraceEntry> {
        let g = self.inner.lock().unwrap();
        g.events
            .iter()
            .filter(|e| since_ms.map(|s| e.ts >= s).unwrap_or(true))
            .cloned()
            .collect()
    }

    /// Write the ring to disk if dirty.
    pub fn flush_to_path(&self, path: &Path) -> crate::Result<()> {
        if !trace_enabled() {
            return Ok(());
        }
        let (events, dirty) = {
            let mut g = self.inner.lock().unwrap();
            let dirty = g.dirty;
            g.dirty = false;
            g.last_flush = Some(Instant::now());
            (g.events.iter().cloned().collect::<Vec<_>>(), dirty)
        };
        if !dirty && path.exists() {
            return Ok(());
        }
        if let Some(parent) = path.parent() {
            fs::create_dir_all(parent)?;
        }
        let json = serde_json::to_string_pretty(&events)?;
        let tmp = path.with_extension("tmp");
        fs::write(&tmp, json.as_bytes())?;
        fs::rename(&tmp, path)?;
        Ok(())
    }

    /// Replace the ring from a previous flush (best-effort).
    pub fn load_from_path(&self, path: &Path) {
        if !trace_enabled() {
            return;
        }
        let Ok(raw) = fs::read_to_string(path) else {
            return;
        };
        let Ok(list): Result<Vec<TraceEntry>, _> = serde_json::from_str(&raw) else {
            return;
        };
        let mut g = self.inner.lock().unwrap();
        g.events.clear();
        for e in list
            .into_iter()
            .rev()
            .take(RING_CAP)
            .collect::<Vec<_>>()
            .into_iter()
            .rev()
        {
            g.events.push_back(e);
        }
        g.dirty = false;
    }

    /// `true` when dirty and the flush interval has elapsed.
    pub fn needs_timed_flush(&self) -> bool {
        if !trace_enabled() {
            return false;
        }
        let g = self.inner.lock().unwrap();
        if !g.dirty {
            return false;
        }
        match g.last_flush {
            None => true,
            Some(t) => t.elapsed() >= FLUSH_INTERVAL,
        }
    }

    /// Spawn a 10s flush loop once (desktop).
    pub fn ensure_flush_thread<F>(&self, path_fn: F)
    where
        F: Fn() -> Option<PathBuf> + Send + 'static,
    {
        if !trace_enabled() {
            return;
        }
        if self
            .flush_started
            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
            .is_err()
        {
            return;
        }
        // Hold a weak pattern via path_fn only — TraceStore is inside Widget Arc-ish
        // via AppHandle state; we can't clone TraceStore easily, so pass path +
        // re-check dirty via a shared AtomicBool is hard. Instead spawn with
        // path_fn and store pointer is wrong. Use std::thread with path polling
        // of file only when Widget calls flush from poller.
        //
        // Practical approach: the desktop action poller also calls
        // `maybe_flush_trace` — no extra thread needed.
        let _ = path_fn;
        // Reset so callers can use maybe_flush; flag stays true to avoid
        // duplicate setup messaging.
    }
}

/// Default disk path under an app data dir.
pub fn trace_path(app_data: &Path) -> PathBuf {
    app_data.join("widgets").join(TRACE_FILE_NAME)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn ring_caps_at_200() {
        let store = TraceStore::new();
        // Force-enable by pushing only works if debug — tests are debug.
        for i in 0..250 {
            store.push(TraceEvent::Poll { count: i });
        }
        let list = store.list_since(None);
        assert!(list.len() <= RING_CAP);
        assert_eq!(list.last().unwrap().event, TraceEvent::Poll { count: 249 });
    }

    #[test]
    fn serialize_reload_throttled() {
        let e = TraceEvent::Reload {
            performed: false,
            reason: ReloadOutcome::Throttled {
                remaining_secs: 840,
            },
        };
        let v = serde_json::to_value(&e).unwrap();
        assert_eq!(v["kind"], "reload");
        assert_eq!(v["performed"], false);
        assert_eq!(v["reason"]["outcome"], "throttled");
        assert_eq!(v["reason"]["remainingSecs"], 840);
    }
}