debug: add early startup probe logging

lius-new · lius-new · commit 191556308e54 · 2026-05-12T01:28:18.000+08:00
diff --git a/src-tauri/src/app/mod.rs b/src-tauri/src/app/mod.rs
@@ -15,46 +15,133 @@ use crate::commands;
 use components::tray;
 
 pub fn run() {
+    crate::core::logger::startup_probe::log("app::run: entered");
     let ctx = tauri::generate_context!();
+    crate::core::logger::startup_probe::log("app::run: tauri context generated");
     let session_lock_manager = session_lock::SessionLockManager::new();
+    crate::core::logger::startup_probe::log("app::run: session lock manager created");
 
-    let app = tauri::Builder::default()
+    let builder = tauri::Builder::default()
         .manage(session_lock_manager.clone())
         .setup(move |app| {
-            setup::register_plugins(app.handle());
+            crate::core::logger::startup_probe::log("app::run setup: begin");
+            setup::register_plugins(app.handle()).map_err(|error| {
+                crate::core::logger::startup_probe::log_error(
+                    "app::run setup: register_plugins failed",
+                    error.to_string(),
+                );
+                anyhow::anyhow!("{}", error)
+            })?;
+            crate::core::logger::startup_probe::log("app::run setup: after register_plugins");
 
             crate::infrastructure::persistence::tauri_store::ensure_store_loaded(app.handle())
-                .map_err(|e| anyhow::anyhow!("{}", e))?;
+                .map_err(|e| {
+                    crate::core::logger::startup_probe::log_error(
+                        "app::run setup: ensure_store_loaded failed",
+                        e.to_string(),
+                    );
+                    anyhow::anyhow!("{}", e)
+                })?;
+            crate::core::logger::startup_probe::log("app::run setup: after ensure_store_loaded");
             let log_dir =
                 crate::infrastructure::persistence::tauri_store::get_logs_path(app.handle())
-                    .map_err(|e| anyhow::anyhow!("{}", e))?;
+                    .map_err(|e| {
+                        crate::core::logger::startup_probe::log_error(
+                            "app::run setup: get_logs_path failed",
+                            e.to_string(),
+                        );
+                        anyhow::anyhow!("{}", e)
+                    })?;
+            crate::core::logger::startup_probe::log(format!(
+                "app::run setup: resolved logs path={}",
+                log_dir.display()
+            ));
             crate::core::logger::init_logging(&log_dir);
-            setup::register_deep_link(app.handle().clone())?;
+            crate::core::logger::startup_probe::log("app::run setup: after logger re-init");
+            setup::register_deep_link(app.handle().clone()).map_err(|error| {
+                crate::core::logger::startup_probe::log_error(
+                    "app::run setup: register_deep_link failed",
+                    error.to_string(),
+                );
+                error
+            })?;
+            crate::core::logger::startup_probe::log("app::run setup: after register_deep_link");
 
-            crate::commands::window::create_splashscreen_window(app.handle().clone())?;
+            crate::commands::window::create_splashscreen_window(app.handle().clone()).map_err(
+                |error| {
+                    crate::core::logger::startup_probe::log_error(
+                        "app::run setup: create_splashscreen_window failed",
+                        error.to_string(),
+                    );
+                    error
+                },
+            )?;
+            crate::core::logger::startup_probe::log(
+                "app::run setup: after create_splashscreen_window",
+            );
 
-            tray::menu(app)?;
+            tray::menu(app).map_err(|error| {
+                crate::core::logger::startup_probe::log_error(
+                    "app::run setup: tray::menu failed",
+                    error.to_string(),
+                );
+                error
+            })?;
+            crate::core::logger::startup_probe::log("app::run setup: after tray::menu");
 
             // 初始化依赖 Tauri 的组件
-            lifecycle::init_tauri_dependent(app.handle())?;
+            lifecycle::init_tauri_dependent(app.handle()).map_err(|error| {
+                crate::core::logger::startup_probe::log_error(
+                    "app::run setup: init_tauri_dependent failed",
+                    error.to_string(),
+                );
+                error
+            })?;
+            crate::core::logger::startup_probe::log(
+                "app::run setup: after lifecycle::init_tauri_dependent",
+            );
 
             setup::init_simprint_runtime_background(app.handle().clone());
+            crate::core::logger::startup_probe::log(
+                "app::run setup: after init_simprint_runtime_background",
+            );
 
             // 初始化会话自动锁定后台任务
             session_lock::init_session_lock_background(
                 app.handle().clone(),
                 session_lock_manager.clone(),
             );
+            crate::core::logger::startup_probe::log(
+                "app::run setup: after init_session_lock_background",
+            );
 
             // 初始化应用启动流程（显示 splashscreen）
             splashscreen::init_startup(app.handle().clone());
+            crate::core::logger::startup_probe::log(
+                "app::run setup: after splashscreen::init_startup",
+            );
+            crate::core::logger::startup_probe::log("app::run setup: completed");
 
             Ok(())
         })
         .invoke_handler(commands::register_handles())
-        .on_window_event(events::window_event_handle)
-        .build(ctx)
-        .expect("error while building application");
+        .on_window_event(events::window_event_handle);
+
+    crate::core::logger::startup_probe::log("app::run: before builder.build(ctx)");
+    let app = match builder.build(ctx) {
+        Ok(app) => {
+            crate::core::logger::startup_probe::log("app::run: after builder.build(ctx)");
+            app
+        }
+        Err(error) => {
+            crate::core::logger::startup_probe::log_error(
+                "app::run: builder.build(ctx) failed",
+                error.to_string(),
+            );
+            panic!("error while building application: {}", error);
+        }
+    };
 
+    crate::core::logger::startup_probe::log("app::run: before app.run");
     app.run(events::run_event_handle);
 }
diff --git a/src-tauri/src/app/setup.rs b/src-tauri/src/app/setup.rs
@@ -3,7 +3,9 @@ use tauri::{AppHandle, Emitter};
 use tauri_plugin_autostart::MacosLauncher;
 
 /// 注册插件
-pub fn register_plugins(app_handle: &AppHandle) {
+pub fn register_plugins(app_handle: &AppHandle) -> anyhow::Result<()> {
+    crate::core::logger::startup_probe::log("setup::register_plugins: begin");
+
     // Register the single instance plugin
     #[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
     #[cfg(feature = "production")]
@@ -27,27 +29,51 @@ pub fn register_plugins(app_handle: &AppHandle) {
                 let _ = main_window.set_focus();
             }
         }))
-        .unwrap();
+        .map_err(|error| anyhow::anyhow!("single_instance plugin init failed: {}", error))?;
+    #[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
+    #[cfg(feature = "production")]
+    crate::core::logger::startup_probe::log("setup::register_plugins: single_instance ok");
 
     // Register process plugin
-    app_handle.plugin(tauri_plugin_process::init()).unwrap();
+    app_handle
+        .plugin(tauri_plugin_process::init())
+        .map_err(|error| anyhow::anyhow!("process plugin init failed: {}", error))?;
+    crate::core::logger::startup_probe::log("setup::register_plugins: process ok");
 
-    app_handle.plugin(tauri_plugin_upload::init()).unwrap();
+    app_handle
+        .plugin(tauri_plugin_upload::init())
+        .map_err(|error| anyhow::anyhow!("upload plugin init failed: {}", error))?;
+    crate::core::logger::startup_probe::log("setup::register_plugins: upload ok");
 
     // deep-link 插件
-    app_handle.plugin(tauri_plugin_deep_link::init()).unwrap();
+    app_handle
+        .plugin(tauri_plugin_deep_link::init())
+        .map_err(|error| anyhow::anyhow!("deep_link plugin init failed: {}", error))?;
+    crate::core::logger::startup_probe::log("setup::register_plugins: deep_link ok");
 
     // opener 插件
-    app_handle.plugin(tauri_plugin_opener::init()).unwrap();
+    app_handle
+        .plugin(tauri_plugin_opener::init())
+        .map_err(|error| anyhow::anyhow!("opener plugin init failed: {}", error))?;
+    crate::core::logger::startup_probe::log("setup::register_plugins: opener ok");
 
     // dialog 插件
-    app_handle.plugin(tauri_plugin_dialog::init()).unwrap();
+    app_handle
+        .plugin(tauri_plugin_dialog::init())
+        .map_err(|error| anyhow::anyhow!("dialog plugin init failed: {}", error))?;
+    crate::core::logger::startup_probe::log("setup::register_plugins: dialog ok");
 
     // store 插件
-    app_handle.plugin(tauri_plugin_store::Builder::new().build()).unwrap();
+    app_handle
+        .plugin(tauri_plugin_store::Builder::new().build())
+        .map_err(|error| anyhow::anyhow!("store plugin init failed: {}", error))?;
+    crate::core::logger::startup_probe::log("setup::register_plugins: store ok");
 
     // clipboard_manager
-    app_handle.plugin(tauri_plugin_clipboard_manager::init()).unwrap();
+    app_handle
+        .plugin(tauri_plugin_clipboard_manager::init())
+        .map_err(|error| anyhow::anyhow!("clipboard_manager plugin init failed: {}", error))?;
+    crate::core::logger::startup_probe::log("setup::register_plugins: clipboard_manager ok");
 
     // 自动启动插件
     #[cfg(desktop)]
@@ -56,17 +82,24 @@ pub fn register_plugins(app_handle: &AppHandle) {
             MacosLauncher::LaunchAgent,
             Some(vec![]), /* 传递给应用程序的任意数量的参数 */
         ))
-        .unwrap();
+        .map_err(|error| anyhow::anyhow!("autostart plugin init failed: {}", error))?;
+    #[cfg(desktop)]
+    crate::core::logger::startup_probe::log("setup::register_plugins: autostart ok");
+
+    crate::core::logger::startup_probe::log("setup::register_plugins: completed");
+    Ok(())
 }
 
 /// 注册深度链接
 #[allow(dead_code)]
 pub fn register_deep_link(app: AppHandle) -> Result<(), anyhow::Error> {
+    crate::core::logger::startup_probe::log("setup::register_deep_link: begin");
     #[cfg(any(windows, target_os = "linux"))]
     {
         use tauri_plugin_deep_link::DeepLinkExt;
         app.deep_link().register_all()?;
     };
+    crate::core::logger::startup_probe::log("setup::register_deep_link: completed");
     Ok(())
 }
 
@@ -89,15 +122,26 @@ pub fn init_server_public_key_background(app_handle: AppHandle) {
 }
 
 pub fn init_simprint_runtime_background(app_handle: AppHandle) {
+    crate::core::logger::startup_probe::log("setup::init_simprint_runtime_background: spawn");
     tauri::async_runtime::spawn(async move {
         use crate::app::context::AppContext;
 
+        crate::core::logger::startup_probe::log(
+            "setup::init_simprint_runtime_background: task begin",
+        );
         let ctx = AppContext::get();
         ctx.simprint_runtime_manager.set_app_handle(app_handle.clone()).await;
         ctx.runtime_update_service.start_background(app_handle.clone());
 
         if let Err(error) = ctx.simprint_runtime_manager.start_background().await {
+            crate::core::logger::startup_probe::log_error(
+                "setup::init_simprint_runtime_background: start_background failed",
+                error.to_string(),
+            );
             log::warn!("failed to start simprint-runtime: {}", error);
         }
+        crate::core::logger::startup_probe::log(
+            "setup::init_simprint_runtime_background: task completed",
+        );
     });
 }
diff --git a/src-tauri/src/core/logger/mod.rs b/src-tauri/src/core/logger/mod.rs
@@ -9,6 +9,7 @@
 
 mod channels;
 pub mod modules;
+pub mod startup_probe;
 mod writer;
 
 pub use channels::{Channel, file_stem_for_target, log_path_for_target};
diff --git a/src-tauri/src/core/logger/startup_probe.rs b/src-tauri/src/core/logger/startup_probe.rs
@@ -0,0 +1,94 @@
+use std::fs::{self, OpenOptions};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::sync::OnceLock;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+static STARTUP_PROBE_PATH: OnceLock<PathBuf> = OnceLock::new();
+
+const STARTUP_PROBE_FILENAME: &str = "simprint-startup-probe.log";
+
+pub fn log(message: impl AsRef<str>) {
+    append("INFO", message.as_ref());
+}
+
+pub fn log_error(stage: &str, error: impl AsRef<str>) {
+    append("ERROR", &format!("{}: {}", stage, error.as_ref()));
+}
+
+pub fn log_panic(panic_info: &std::panic::PanicHookInfo) {
+    let location = panic_info
+        .location()
+        .map(|location| format!("{}:{}", location.file(), location.line()))
+        .unwrap_or_else(|| "unknown".to_string());
+    let message = if let Some(message) = panic_info.payload().downcast_ref::<String>() {
+        message.as_str()
+    } else if let Some(message) = panic_info.payload().downcast_ref::<&str>() {
+        message
+    } else {
+        "unknown panic payload"
+    };
+
+    append("PANIC", &format!("at {}: {}", location, message));
+}
+
+pub fn current_path() -> Option<&'static Path> {
+    STARTUP_PROBE_PATH.get().map(PathBuf::as_path)
+}
+
+fn append(level: &str, message: &str) {
+    let line = format!(
+        "[{}][pid:{}][{}] {}\n",
+        unix_timestamp_millis(),
+        std::process::id(),
+        level,
+        message
+    );
+
+    if let Some(path) = STARTUP_PROBE_PATH.get() {
+        if try_append(path, &line).is_ok() {
+            return;
+        }
+    }
+
+    for candidate in candidate_paths() {
+        if try_append(&candidate, &line).is_ok() {
+            let _ = STARTUP_PROBE_PATH.set(candidate);
+            return;
+        }
+    }
+}
+
+fn candidate_paths() -> Vec<PathBuf> {
+    let mut paths = Vec::new();
+
+    if let Ok(dir) = crate::core::paths::PathManager::get_bootstrap_logs_dir() {
+        paths.push(dir.join(STARTUP_PROBE_FILENAME));
+    }
+
+    paths.push(std::env::temp_dir().join(STARTUP_PROBE_FILENAME));
+
+    if let Ok(cwd) = std::env::current_dir() {
+        paths.push(cwd.join(STARTUP_PROBE_FILENAME));
+    }
+
+    paths
+}
+
+fn try_append(path: &Path, line: &str) -> std::io::Result<()> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    let mut file = OpenOptions::new().create(true).append(true).open(path)?;
+    file.write_all(line.as_bytes())?;
+    file.flush()?;
+    Ok(())
+}
+
+fn unix_timestamp_millis() -> u128 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_millis())
+        .unwrap_or(0)
+}
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
