diff --git a/src-tauri/src/cmd/app.rs b/src-tauri/src/cmd/app.rs
index 99fb12b8..f428069f 100644
--- a/src-tauri/src/cmd/app.rs
+++ b/src-tauri/src/cmd/app.rs
@@ -200,7 +200,7 @@ pub fn copy_icon_file(path: String, icon_info: IconInfo) -> CmdResult<String> {
         }
         logging!(
             info,
-            Type::CMD,
+            Type::Cmd,
             true,
             "Copying icon file path: {:?} -> file dist: {:?}",
             path,
diff --git a/src-tauri/src/cmd/profile.rs b/src-tauri/src/cmd/profile.rs
index 0b1c4662..b9ebcc4e 100644
--- a/src-tauri/src/cmd/profile.rs
+++ b/src-tauri/src/cmd/profile.rs
@@ -1,8 +1,8 @@
 use super::CmdResult;
 use crate::{
     config::*,
-    core::*,
-    feat, log_err, logging, ret_err,
+    core::{tray::Tray, *},
+    feat, logging, logging_error, ret_err,
     utils::{dirs, help, logging::Type},
     wrap_err,
 };
@@ -19,8 +19,8 @@ pub fn get_profiles() -> CmdResult<IProfiles> {
 pub async fn enhance_profiles() -> CmdResult {
     match CoreManager::global().update_config().await {
         Ok((true, _)) => {
-            println!("[enhance_profiles] 配置更新成功");
-            log_err!(tray::Tray::global().update_tooltip());
+            logging!(info, Type::Cmd, true, "配置更新成功");
+            logging_error!(Type::Tray, true, Tray::global().update_tooltip());
             handle::Handle::refresh_clash();
             Ok(())
         }
@@ -77,19 +77,19 @@ pub async fn delete_profile(index: String) -> CmdResult {
 /// 修改profiles的配置
 #[tauri::command]
 pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
-    logging!(info, Type::CMD, true, "开始修改配置文件");
+    logging!(info, Type::Cmd, true, "开始修改配置文件");
 
     // 保存当前配置，以便在验证失败时恢复
     let current_profile = Config::profiles().latest().current.clone();
-    logging!(info, Type::CMD, true, "当前配置: {:?}", current_profile);
+    logging!(info, Type::Cmd, true, "当前配置: {:?}", current_profile);
 
     // 更新profiles配置
-    logging!(info, Type::CMD, true, "正在更新配置草稿");
+    logging!(info, Type::Cmd, true, "正在更新配置草稿");
     wrap_err!({ Config::profiles().draft().patch_config(profiles) })?;
     // 更新配置并进行验证
     match CoreManager::global().update_config().await {
         Ok((true, _)) => {
-            logging!(info, Type::CMD, true, "配置更新成功");
+            logging!(info, Type::Cmd, true, "配置更新成功");
             handle::Handle::refresh_clash();
             let _ = tray::Tray::global().update_tooltip();
             Config::profiles().apply();
@@ -97,13 +97,13 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
             Ok(true)
         }
         Ok((false, error_msg)) => {
-            logging!(warn, Type::CMD, true, "配置验证失败: {}", error_msg);
+            logging!(warn, Type::Cmd, true, "配置验证失败: {}", error_msg);
             Config::profiles().discard();
             // 如果验证失败，恢复到之前的配置
             if let Some(prev_profile) = current_profile {
                 logging!(
                     info,
-                    Type::CMD,
+                    Type::Cmd,
                     true,
                     "尝试恢复到之前的配置: {}",
                     prev_profile
@@ -116,7 +116,7 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
                 wrap_err!({ Config::profiles().draft().patch_config(restore_profiles) })?;
                 Config::profiles().apply();
                 wrap_err!(Config::profiles().data().save_file())?;
-                logging!(info, Type::CMD, true, "成功恢复到之前的配置");
+                logging!(info, Type::Cmd, true, "成功恢复到之前的配置");
             }
 
             // 发送验证错误通知
@@ -124,7 +124,7 @@ pub async fn patch_profiles_config(profiles: IProfiles) -> CmdResult<bool> {
             Ok(false)
         }
         Err(e) => {
-            logging!(warn, Type::CMD, true, "更新过程发生错误: {}", e);
+            logging!(warn, Type::Cmd, true, "更新过程发生错误: {}", e);
             Config::profiles().discard();
             handle::Handle::notice_message("config_validate::boot_error", e.to_string());
             Ok(false)
diff --git a/src-tauri/src/cmd/service.rs b/src-tauri/src/cmd/service.rs
index 7974ae28..84d3328a 100644
--- a/src-tauri/src/cmd/service.rs
+++ b/src-tauri/src/cmd/service.rs
@@ -5,34 +5,39 @@ use crate::{
     utils::logging::Type,
 };
 
+async fn execute_service_operation(
+    service_op: impl std::future::Future<Output = Result<(), impl ToString + std::fmt::Debug>>,
+    op_type: &str,
+) -> CmdResult {
+    if let Err(e) = service_op.await {
+        let emsg = format!("{} {} failed: {:?}", op_type, "service", e);
+        logging_error!(Type::Service, true, "{}", emsg);
+        return Err(emsg);
+    }
+    if let Err(e) = CoreManager::global().restart_core().await {
+        let emsg = format!("{} {} failed: {:?}", op_type, "core", e);
+        logging_error!(Type::Core, true, "{}", emsg);
+        return Err(emsg);
+    }
+    Ok(())
+}
+
 #[tauri::command]
 pub async fn install_service() -> CmdResult {
-    logging_error!(Type::Service, true, service::install_service().await);
-    logging_error!(Type::Core, true, CoreManager::global().restart_core().await);
-    Ok(())
+    execute_service_operation(service::install_service(), "Install").await
 }
 
 #[tauri::command]
 pub async fn uninstall_service() -> CmdResult {
-    logging_error!(Type::Service, true, service::uninstall_service().await);
-    logging_error!(Type::Core, true, CoreManager::global().restart_core().await);
-    Ok(())
+    execute_service_operation(service::uninstall_service(), "Uninstall").await
 }
 
 #[tauri::command]
 pub async fn reinstall_service() -> CmdResult {
-    logging_error!(Type::Service, true, service::reinstall_service().await);
-    logging_error!(Type::Core, true, CoreManager::global().restart_core().await);
-    Ok(())
+    execute_service_operation(service::reinstall_service(), "Reinstall").await
 }
 
 #[tauri::command]
 pub async fn repair_service() -> CmdResult {
-    logging_error!(
-        Type::Service,
-        true,
-        service::force_reinstall_service().await
-    );
-    logging_error!(Type::Core, true, CoreManager::global().restart_core().await);
-    Ok(())
+    execute_service_operation(service::force_reinstall_service(), "Repair").await
 }
diff --git a/src-tauri/src/config/config.rs b/src-tauri/src/config/config.rs
index 26fb68a5..6e32e59c 100644
--- a/src-tauri/src/config/config.rs
+++ b/src-tauri/src/config/config.rs
@@ -66,9 +66,12 @@ impl Config {
             let script_item = PrfItem::from_script(Some("Script".to_string()))?;
             Self::profiles().data().append_item(script_item.clone())?;
         }
-
         // 生成运行时配置
-        crate::log_err!(Self::generate().await);
+        if let Err(err) = Self::generate().await {
+            logging!(error, Type::Config, true, "生成运行时配置失败: {}", err);
+        } else {
+            logging!(info, Type::Config, true, "生成运行时配置成功");
+        }
 
         // 生成运行时配置文件并验证
         let config_result = Self::generate_file(ConfigType::Run);
diff --git a/src-tauri/src/core/handle.rs b/src-tauri/src/core/handle.rs
index eef12f0c..2cae995f 100644
--- a/src-tauri/src/core/handle.rs
+++ b/src-tauri/src/core/handle.rs
@@ -1,9 +1,10 @@
-use crate::log_err;
 use once_cell::sync::OnceCell;
 use parking_lot::RwLock;
 use std::sync::Arc;
 use tauri::{AppHandle, Emitter, Manager, WebviewWindow};
 
+use crate::{logging_error, utils::logging::Type};
+
 #[derive(Debug, Default, Clone)]
 pub struct Handle {
     pub app_handle: Arc<RwLock<Option<AppHandle>>>,
@@ -40,26 +41,42 @@ impl Handle {
 
     pub fn refresh_clash() {
         if let Some(window) = Self::global().get_window() {
-            log_err!(window.emit("verge://refresh-clash-config", "yes"));
+            logging_error!(
+                Type::Frontend,
+                true,
+                window.emit("verge://refresh-clash-config", "yes")
+            );
         }
     }
 
     pub fn refresh_verge() {
         if let Some(window) = Self::global().get_window() {
-            log_err!(window.emit("verge://refresh-verge-config", "yes"));
+            logging_error!(
+                Type::Frontend,
+                true,
+                window.emit("verge://refresh-verge-config", "yes")
+            );
         }
     }
 
     #[allow(unused)]
     pub fn refresh_profiles() {
         if let Some(window) = Self::global().get_window() {
-            log_err!(window.emit("verge://refresh-profiles-config", "yes"));
+            logging_error!(
+                Type::Frontend,
+                true,
+                window.emit("verge://refresh-profiles-config", "yes")
+            );
         }
     }
 
     pub fn notice_message<S: Into<String>, M: Into<String>>(status: S, msg: M) {
         if let Some(window) = Self::global().get_window() {
-            log_err!(window.emit("verge://notice-message", (status.into(), msg.into())));
+            logging_error!(
+                Type::Frontend,
+                true,
+                window.emit("verge://notice-message", (status.into(), msg.into()))
+            );
         }
     }
 
diff --git a/src-tauri/src/core/hotkey.rs b/src-tauri/src/core/hotkey.rs
index cc95b2c4..4f89694a 100755
--- a/src-tauri/src/core/hotkey.rs
+++ b/src-tauri/src/core/hotkey.rs
@@ -1,7 +1,7 @@
 use crate::{
     config::Config,
     core::handle,
-    feat, log_err, logging,
+    feat, logging, logging_error,
     module::lightweight::entry_lightweight_mode,
     utils::{logging::Type, resolve},
 };
@@ -285,7 +285,7 @@ impl Hotkey {
         });
 
         add.iter().for_each(|(key, func)| {
-            log_err!(self.register(key, func));
+            logging_error!(Type::Hotkey, true, self.register(key, func));
         });
 
         *current = new_hotkeys;
diff --git a/src-tauri/src/core/sysopt.rs b/src-tauri/src/core/sysopt.rs
index 7e22e3dc..67c92203 100644
--- a/src-tauri/src/core/sysopt.rs
+++ b/src-tauri/src/core/sysopt.rs
@@ -1,7 +1,8 @@
 use crate::{
     config::{Config, IVerge},
     core::handle::Handle,
-    log_err,
+    logging_error,
+    utils::logging::Type,
 };
 use anyhow::Result;
 use once_cell::sync::OnceCell;
@@ -231,7 +232,7 @@ impl Sysopt {
                 } else {
                     log::info!(target: "app", "Auto launch enabled successfully");
                 }
-                log_err!(result)
+                logging_error!(Type::System, true, result);
             }
             false => {
                 let result = autostart_manager.disable();
@@ -240,7 +241,7 @@ impl Sysopt {
                 } else {
                     log::info!(target: "app", "Auto launch disabled successfully");
                 }
-                log_err!(result)
+                logging_error!(Type::System, true, result);
             }
         };
 
@@ -323,7 +324,7 @@ impl Sysopt {
                             enable: true,
                             url: format!("http://127.0.0.1:{pac_port}/commands/pac"),
                         };
-                        log_err!(autoproxy.set_auto_proxy());
+                        logging_error!(Type::System, true, autoproxy.set_auto_proxy());
                     } else {
                         let sysproxy = Sysproxy {
                             enable: true,
@@ -332,7 +333,7 @@ impl Sysopt {
                             bypass: get_bypass(),
                         };
 
-                        log_err!(sysproxy.set_system_proxy());
+                        logging_error!(Type::System, true, sysproxy.set_system_proxy());
                     }
                 }
 
diff --git a/src-tauri/src/core/tray/mod.rs b/src-tauri/src/core/tray/mod.rs
index 16482389..75db0375 100644
--- a/src-tauri/src/core/tray/mod.rs
+++ b/src-tauri/src/core/tray/mod.rs
@@ -8,7 +8,7 @@ use crate::{
     feat,
     module::{lightweight::entry_lightweight_mode, mihomo::Rate},
     resolve,
-    utils::{dirs::find_target_icons, i18n::t, resolve::VERSION},
+    utils::{dirs::find_target_icons, i18n::t, logging::Type, resolve::VERSION},
 };
 
 use anyhow::Result;
@@ -684,9 +684,9 @@ fn on_menu_event(_: &AppHandle, event: MenuEvent) {
         "system_proxy" => feat::toggle_system_proxy(),
         "tun_mode" => feat::toggle_tun_mode(None),
         "copy_env" => feat::copy_clash_env(),
-        "open_app_dir" => crate::log_err!(cmd::open_app_dir()),
-        "open_core_dir" => crate::log_err!(cmd::open_core_dir()),
-        "open_logs_dir" => crate::log_err!(cmd::open_logs_dir()),
+        "open_app_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_app_dir()),
+        "open_core_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_core_dir()),
+        "open_logs_dir" => crate::logging_error!(Type::Cmd, true, cmd::open_logs_dir()),
         "restart_clash" => feat::restart_clash_core(),
         "restart_app" => feat::restart_app(),
         "entry_lightweight_mode" => entry_lightweight_mode(),
diff --git a/src-tauri/src/error/mod.rs b/src-tauri/src/error/mod.rs
new file mode 100644
index 00000000..1f278a4d
--- /dev/null
+++ b/src-tauri/src/error/mod.rs
@@ -0,0 +1 @@
+pub mod service;
diff --git a/src-tauri/src/error/service.rs b/src-tauri/src/error/service.rs
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/src-tauri/src/error/service.rs
@@ -0,0 +1 @@
+
diff --git a/src-tauri/src/feat/backup.rs b/src-tauri/src/feat/backup.rs
index fa3dd968..d1e2dd58 100644
--- a/src-tauri/src/feat/backup.rs
+++ b/src-tauri/src/feat/backup.rs
@@ -1,8 +1,8 @@
 use crate::{
     config::{Config, IVerge},
     core::backup,
-    log_err,
-    utils::dirs::app_home_dir,
+    logging_error,
+    utils::{dirs::app_home_dir, logging::Type},
 };
 use anyhow::Result;
 use reqwest_dav::list_cmd::ListFile;
@@ -69,8 +69,9 @@ pub async fn restore_webdav_backup(filename: String) -> Result<()> {
     // extract zip file
     let mut zip = zip::ZipArchive::new(fs::File::open(backup_storage_path.clone())?)?;
     zip.extract(app_home_dir()?)?;
-
-    log_err!(
+    logging_error!(
+        Type::Backup,
+        true,
         super::patch_verge(
             IVerge {
                 webdav_url,
diff --git a/src-tauri/src/feat/clash.rs b/src-tauri/src/feat/clash.rs
index 84696c78..a5da53ed 100644
--- a/src-tauri/src/feat/clash.rs
+++ b/src-tauri/src/feat/clash.rs
@@ -1,9 +1,9 @@
 use crate::{
     config::Config,
     core::{handle, tray, CoreManager},
-    log_err,
+    logging_error,
     module::mihomo::MihomoManager,
-    utils::resolve,
+    utils::{logging::Type, resolve},
 };
 use serde_yaml::{Mapping, Value};
 use tauri::Manager;
@@ -28,7 +28,7 @@ pub fn restart_clash_core() {
 pub fn restart_app() {
     tauri::async_runtime::spawn_blocking(|| {
         tauri::async_runtime::block_on(async {
-            log_err!(CoreManager::global().stop_core().await);
+            logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
         });
         resolve::resolve_reset();
         let app_handle = handle::Handle::global().app_handle().unwrap();
@@ -54,8 +54,8 @@ pub fn change_clash_mode(mode: String) {
 
                 if Config::clash().data().save_config().is_ok() {
                     handle::Handle::refresh_clash();
-                    log_err!(tray::Tray::global().update_menu());
-                    log_err!(tray::Tray::global().update_icon(None));
+                    logging_error!(Type::Tray, true, tray::Tray::global().update_menu());
+                    logging_error!(Type::Tray, true, tray::Tray::global().update_icon(None));
                 }
             }
             Err(err) => println!("{err}"),
diff --git a/src-tauri/src/feat/config.rs b/src-tauri/src/feat/config.rs
index d0a8bea9..f4810d0b 100644
--- a/src-tauri/src/feat/config.rs
+++ b/src-tauri/src/feat/config.rs
@@ -1,8 +1,9 @@
 use crate::{
     config::{Config, IVerge},
     core::{handle, hotkey, sysopt, tray, CoreManager},
-    log_err,
+    logging_error,
     module::lightweight,
+    utils::logging::Type,
 };
 use anyhow::Result;
 use serde_yaml::Mapping;
@@ -18,8 +19,8 @@ pub async fn patch_clash(patch: Mapping) -> Result<()> {
             CoreManager::global().restart_core().await?;
         } else {
             if patch.get("mode").is_some() {
-                log_err!(tray::Tray::global().update_menu());
-                log_err!(tray::Tray::global().update_icon(None));
+                logging_error!(Type::Tray, true, tray::Tray::global().update_menu());
+                logging_error!(Type::Tray, true, tray::Tray::global().update_icon(None));
             }
             Config::runtime().latest().patch_config(patch);
             CoreManager::global().update_config().await?;
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 22806248..4a77183f 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -2,6 +2,7 @@ mod cmd;
 mod config;
 mod core;
 mod enhance;
+mod error;
 mod feat;
 mod module;
 mod utils;
@@ -16,6 +17,7 @@ use tauri::AppHandle;
 use tauri::Manager;
 use tauri_plugin_autostart::MacosLauncher;
 use tauri_plugin_deep_link::DeepLinkExt;
+use utils::logging::Type;
 
 /// A global singleton handle to the application.
 pub struct AppHandleManager {
@@ -119,13 +121,13 @@ pub fn run() {
             #[cfg(any(target_os = "linux", all(debug_assertions, windows)))]
             {
                 use tauri_plugin_deep_link::DeepLinkExt;
-                log_err!(app.deep_link().register_all());
+                logging_error!(Type::System, true, app.deep_link().register_all());
             }
 
             app.deep_link().on_open_url(|event| {
                 tauri::async_runtime::spawn(async move {
                     if let Some(url) = event.urls().first() {
-                        log_err!(resolve_scheme(url.to_string()).await);
+                        logging_error!(Type::Setup, true, resolve_scheme(url.to_string()).await);
                     }
                 });
             });
@@ -279,13 +281,25 @@ pub fn run() {
                     tauri::WindowEvent::Focused(true) => {
                         #[cfg(target_os = "macos")]
                         {
-                            log_err!(hotkey::Hotkey::global().register("CMD+Q", "quit"));
-                            log_err!(hotkey::Hotkey::global().register("CMD+W", "hide"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().register("CMD+Q", "quit")
+                            );
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().register("CMD+W", "hide")
+                            );
                         }
 
                         #[cfg(not(target_os = "macos"))]
                         {
-                            log_err!(hotkey::Hotkey::global().register("Control+Q", "quit"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().register("Control+Q", "quit")
+                            );
                         };
                         {
                             let is_enable_global_hotkey = Config::verge()
@@ -293,19 +307,31 @@ pub fn run() {
                                 .enable_global_hotkey
                                 .unwrap_or(true);
                             if !is_enable_global_hotkey {
-                                log_err!(hotkey::Hotkey::global().init())
+                                logging_error!(Type::Hotkey, true, hotkey::Hotkey::global().init())
                             }
                         }
                     }
                     tauri::WindowEvent::Focused(false) => {
                         #[cfg(target_os = "macos")]
                         {
-                            log_err!(hotkey::Hotkey::global().unregister("CMD+Q"));
-                            log_err!(hotkey::Hotkey::global().unregister("CMD+W"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("CMD+Q")
+                            );
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("CMD+W")
+                            );
                         }
                         #[cfg(not(target_os = "macos"))]
                         {
-                            log_err!(hotkey::Hotkey::global().unregister("Control+Q"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("Control+Q")
+                            );
                         };
                         {
                             let is_enable_global_hotkey = Config::verge()
@@ -313,20 +339,32 @@ pub fn run() {
                                 .enable_global_hotkey
                                 .unwrap_or(true);
                             if !is_enable_global_hotkey {
-                                log_err!(hotkey::Hotkey::global().reset())
+                                logging_error!(Type::Hotkey, true, hotkey::Hotkey::global().reset())
                             }
                         }
                     }
                     tauri::WindowEvent::Destroyed => {
                         #[cfg(target_os = "macos")]
                         {
-                            log_err!(hotkey::Hotkey::global().unregister("CMD+Q"));
-                            log_err!(hotkey::Hotkey::global().unregister("CMD+W"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("CMD+Q")
+                            );
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("CMD+W")
+                            );
                         }
 
                         #[cfg(not(target_os = "macos"))]
                         {
-                            log_err!(hotkey::Hotkey::global().unregister("Control+Q"));
+                            logging_error!(
+                                Type::Hotkey,
+                                true,
+                                hotkey::Hotkey::global().unregister("Control+Q")
+                            );
                         };
                     }
                     _ => {}
diff --git a/src-tauri/src/module/lightweight.rs b/src-tauri/src/module/lightweight.rs
index a181ef85..f6626e4e 100644
--- a/src-tauri/src/module/lightweight.rs
+++ b/src-tauri/src/module/lightweight.rs
@@ -5,21 +5,21 @@ use tauri::{Listener, Manager};
 use crate::{
     config::Config,
     core::{handle, timer::Timer},
-    log_err, AppHandleManager,
+    log_err, logging,
+    utils::logging::Type,
+    AppHandleManager,
 };
 
 const LIGHT_WEIGHT_TASK_UID: &str = "light_weight_task";
 
 pub fn enable_auto_light_weight_mode() {
-    println!("[lightweight_mode] 开启自动轻量模式");
-    log::info!(target: "app", "[lightweight_mode] 开启自动轻量模式");
+    logging!(info, Type::Lightweight, True, "开启自动轻量模式");
     setup_window_close_listener();
     setup_webview_focus_listener();
 }
 
 pub fn disable_auto_light_weight_mode() {
-    println!("[lightweight_mode] 关闭自动轻量模式");
-    log::info!(target: "app", "[lightweight_mode] 关闭自动轻量模式");
+    logging!(info, Type::Lightweight, True, "关闭自动轻量模式");
     let _ = cancel_light_weight_timer();
     cancel_window_close_listener();
 }
@@ -34,8 +34,7 @@ pub fn entry_lightweight_mode() {
         }
         #[cfg(target_os = "macos")]
         AppHandleManager::global().set_activation_policy_accessory();
-        println!("[lightweight_mode] 轻量模式已开启");
-        log::info!(target: "app", "[lightweight_mode] 轻量模式已开启");
+        logging!(info, Type::Lightweight, True, "轻量模式已开启");
     }
     let _ = cancel_light_weight_timer();
 }
@@ -44,8 +43,12 @@ fn setup_window_close_listener() -> u32 {
     if let Some(window) = handle::Handle::global().get_window() {
         let handler = window.listen("tauri://close-requested", move |_event| {
             let _ = setup_light_weight_timer();
-            println!("[lightweight_mode] 监听到关闭请求，开始轻量模式计时");
-            log::info!(target: "app", "[lightweight_mode] 监听到关闭请求，开始轻量模式计时");
+            logging!(
+                info,
+                Type::Lightweight,
+                True,
+                "监听到关闭请求，开始轻量模式计时"
+            );
         });
         return handler;
     }
@@ -56,8 +59,12 @@ fn setup_webview_focus_listener() -> u32 {
     if let Some(window) = handle::Handle::global().get_window() {
         let handler = window.listen("tauri://focus", move |_event| {
             log_err!(cancel_light_weight_timer());
-            println!("[lightweight_mode] 监听到窗口获得焦点，取消轻量模式计时");
-            log::info!(target: "app", "[lightweight_mode] 监听到窗口获得焦点，取消轻量模式计时");
+            logging!(
+                info,
+                Type::Lightweight,
+                True,
+                "监听到窗口获得焦点，取消轻量模式计时"
+            );
         });
         return handler;
     }
@@ -67,8 +74,7 @@ fn setup_webview_focus_listener() -> u32 {
 fn cancel_window_close_listener() {
     if let Some(window) = handle::Handle::global().get_window() {
         window.unlisten(setup_window_close_listener());
-        println!("[lightweight_mode] 取消了窗口关闭监听");
-        log::info!(target: "app", "[lightweight_mode] 取消了窗口关闭监听");
+        logging!(info, Type::Lightweight, True, "取消了窗口关闭监听");
     }
 }
 
@@ -92,17 +98,14 @@ fn setup_light_weight_timer() -> Result<()> {
         .set_maximum_parallel_runnable_num(1)
         .set_frequency_once_by_minutes(once_by_minutes)
         .spawn_async_routine(move || async move {
-            println!("[lightweight_mode] 计时器到期，开始进入轻量模式");
-            log::info!(target: "app",
-                "[lightweight_mode] 计时器到期，开始进入轻量模式"
-            );
+            logging!(info, Type::Timer, True, "计时器到期，开始进入轻量模式");
             entry_lightweight_mode();
         })
-        .context("failed to create light weight timer task")?;
+        .context("failed to create timer task")?;
 
     delay_timer
         .add_task(task)
-        .context("failed to add light weight timer task")?;
+        .context("failed to add timer task")?;
 
     let timer_task = crate::core::timer::TimerTask {
         task_id,
@@ -112,12 +115,11 @@ fn setup_light_weight_timer() -> Result<()> {
 
     timer_map.insert(LIGHT_WEIGHT_TASK_UID.to_string(), timer_task);
 
-    println!(
-        "[lightweight_mode] 轻量模式计时器已设置，{} 分钟后将自动进入轻量模式",
-        once_by_minutes
-    );
-    log::info!(target: "app",
-        "[lightweight_mode] 轻量模式计时器已设置，{} 分钟后将自动进入轻量模式",
+    logging!(
+        info,
+        Type::Timer,
+        True,
+        "计时器已设置，{} 分钟后将自动进入轻量模式",
         once_by_minutes
     );
 
@@ -131,9 +133,8 @@ fn cancel_light_weight_timer() -> Result<()> {
     if let Some(task) = timer_map.remove(LIGHT_WEIGHT_TASK_UID) {
         delay_timer
             .remove_task(task.task_id)
-            .context("failed to remove light weight timer task")?;
-        println!("[lightweight_mode] 轻量模式计时器已取消");
-        log::info!(target: "app", "[lightweight_mode] 轻量模式计时器已取消");
+            .context("failed to remove timer task")?;
+        logging!(info, Type::Timer, True, "计时器已取消");
     }
 
     Ok(())
diff --git a/src-tauri/src/utils/logging.rs b/src-tauri/src/utils/logging.rs
index 4a46fb95..dfb0afd1 100644
--- a/src-tauri/src/utils/logging.rs
+++ b/src-tauri/src/utils/logging.rs
@@ -2,23 +2,37 @@ use std::fmt;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Type {
+    Cmd,
     Core,
+    Config,
+    Setup,
+    System,
     Service,
     Hotkey,
     Window,
-    Config,
-    CMD,
+    Tray,
+    Timer,
+    Frontend,
+    Backup,
+    Lightweight,
 }
 
 impl fmt::Display for Type {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
+            Type::Cmd => write!(f, "[Cmd]"),
             Type::Core => write!(f, "[Core]"),
+            Type::Config => write!(f, "[Config]"),
+            Type::Setup => write!(f, "[Setup]"),
+            Type::System => write!(f, "[System]"),
             Type::Service => write!(f, "[Service]"),
             Type::Hotkey => write!(f, "[Hotkey]"),
             Type::Window => write!(f, "[Window]"),
-            Type::Config => write!(f, "[Config]"),
-            Type::CMD => write!(f, "[CMD]"),
+            Type::Tray => write!(f, "[Tray]"),
+            Type::Timer => write!(f, "[Timer]"),
+            Type::Frontend => write!(f, "[Frontend]"),
+            Type::Backup => write!(f, "[Backup]"),
+            Type::Lightweight => write!(f, "[Lightweight]"),
         }
     }
 }
diff --git a/src-tauri/src/utils/resolve.rs b/src-tauri/src/utils/resolve.rs
index 9c7d9fbe..04c2eb52 100644
--- a/src-tauri/src/utils/resolve.rs
+++ b/src-tauri/src/utils/resolve.rs
@@ -3,7 +3,7 @@ use crate::AppHandleManager;
 use crate::{
     config::{Config, IVerge, PrfItem},
     core::*,
-    log_err, logging,
+    logging, logging_error,
     module::lightweight,
     utils::{error, init, logging::Type, server},
     wrap_err,
@@ -51,15 +51,15 @@ pub async fn resolve_setup(app: &mut App) {
     handle::Handle::global().init(app.app_handle());
     VERSION.get_or_init(|| version.clone());
 
-    log_err!(init::init_config());
-    log_err!(init::init_resources());
-    log_err!(init::init_scheme());
-    log_err!(init::startup_script().await);
+    logging_error!(Type::Config, true, init::init_config());
+    logging_error!(Type::Setup, true, init::init_resources());
+    logging_error!(Type::Setup, true, init::init_scheme());
+    logging_error!(Type::Setup, true, init::startup_script().await);
     // 处理随机端口
-    log_err!(resolve_random_port_config());
+    logging_error!(Type::System, true, resolve_random_port_config());
     // 启动核心
-    log::trace!(target:"app", "init config");
-    log_err!(Config::init_config().await);
+    logging!(trace, Type::Config, true, "Initial config");
+    logging_error!(Type::Config, true, Config::init_config().await);
 
     // if service::check_service().await.is_err() {
     //     match service::install_service().await {
@@ -90,31 +90,39 @@ pub async fn resolve_setup(app: &mut App) {
     //     }
     // }
 
-    log::trace!(target: "app", "launch core");
-    log_err!(CoreManager::global().init().await);
+    logging!(trace, Type::Core, "Starting CoreManager");
+    logging_error!(Type::Core, true, CoreManager::global().init().await);
 
     // setup a simple http server for singleton
     log::trace!(target: "app", "launch embed server");
     server::embed_server();
 
-    log::trace!(target: "app", "init system tray");
-    log_err!(tray::Tray::global().init());
-    log_err!(tray::Tray::global().create_systray(app));
+    log::trace!(target: "app", "Initial system tray");
+    logging_error!(Type::Tray, true, tray::Tray::global().init());
+    logging_error!(Type::Tray, true, tray::Tray::global().create_systray(app));
 
-    log_err!(sysopt::Sysopt::global().update_sysproxy().await);
-    log_err!(sysopt::Sysopt::global().init_guard_sysproxy());
+    logging_error!(
+        Type::System,
+        true,
+        sysopt::Sysopt::global().update_sysproxy().await
+    );
+    logging_error!(
+        Type::System,
+        true,
+        sysopt::Sysopt::global().init_guard_sysproxy()
+    );
 
     // 初始化热键
-    log::trace!(target: "app", "init hotkeys");
-    log_err!(hotkey::Hotkey::global().init());
+    logging!(trace, Type::System, true, "Initial hotkeys");
+    logging_error!(Type::System, true, hotkey::Hotkey::global().init());
 
     let silent_start = { Config::verge().data().enable_silent_start };
     if !silent_start.unwrap_or(false) {
         create_window();
     }
 
-    log_err!(tray::Tray::global().update_part());
-    log_err!(timer::Timer::global().init());
+    logging_error!(Type::Tray, true, tray::Tray::global().update_part());
+    logging_error!(Type::System, true, timer::Timer::global().init());
 
     let enable_auto_light_weight_mode = { Config::verge().data().enable_auto_light_weight_mode };
     if enable_auto_light_weight_mode.unwrap_or(false) {
@@ -126,12 +134,20 @@ pub async fn resolve_setup(app: &mut App) {
 pub fn resolve_reset() {
     tauri::async_runtime::block_on(async move {
         #[cfg(target_os = "macos")]
+        logging!(info, Type::Tray, true, "Unsubscribing from traffic updates");
         tray::Tray::global().unsubscribe_traffic();
 
-        log_err!(sysopt::Sysopt::global().reset_sysproxy().await);
-        log_err!(CoreManager::global().stop_core().await);
+        logging_error!(
+            Type::System,
+            true,
+            sysopt::Sysopt::global().reset_sysproxy().await
+        );
+        logging_error!(Type::Core, true, CoreManager::global().stop_core().await);
         #[cfg(target_os = "macos")]
-        restore_public_dns().await;
+        {
+            logging!(info, Type::System, true, "Restoring system DNS settings");
+            restore_public_dns().await;
+        }
     });
 }
 
diff --git a/src-tauri/src/utils/server.rs b/src-tauri/src/utils/server.rs
index 1baee60b..5322d790 100644
--- a/src-tauri/src/utils/server.rs
+++ b/src-tauri/src/utils/server.rs
@@ -3,7 +3,8 @@ extern crate warp;
 use super::resolve;
 use crate::{
     config::{Config, IVerge, DEFAULT_PAC},
-    log_err,
+    logging_error,
+    utils::logging::Type,
 };
 use anyhow::{bail, Result};
 use port_scanner::local_port_available;
@@ -69,7 +70,11 @@ pub fn embed_server() {
                 .unwrap_or_default()
         });
         async fn scheme_handler(query: QueryParam) -> Result<impl warp::Reply, Infallible> {
-            log_err!(resolve::resolve_scheme(query.param).await);
+            logging_error!(
+                Type::Setup,
+                true,
+                resolve::resolve_scheme(query.param).await
+            );
             Ok("ok")
         }