Use correct logging filename (#714)

Author: moubctez

src-tauri/src/bin/defguard-client.rs

@@ -29,7 +29,7 @@ use defguard_client::{
     service,
     tray::{configure_tray_icon, setup_tray, show_main_window},
     utils::load_log_targets,
-    VERSION,
+    LOG_FILENAME, VERSION,
 };
 use log::{Level, LevelFilter};
 use tauri::{AppHandle, Builder, Manager, RunEvent, WindowEvent};
@@ -286,7 +286,7 @@ fn main() {
                     })
                     .targets([
                         Target::new(TargetKind::Stdout),
-                        Target::new(TargetKind::LogDir { file_name: None }),
+                        Target::new(TargetKind::LogDir { file_name: Some(LOG_FILENAME.to_string()) }),
                     ])
                     .level(log_level)
                     .filter(|metadata| {
@@ -364,9 +364,11 @@ fn main() {
             }
 
             info!(
-                "Application data (database file) will be stored in: {data_dir:?} and application \
-                logs in: {log_dir:?}. Logs of the background Defguard service responsible for \
-                managing VPN connections at the network level will be stored in: {}.",
+                "Application data (database file) will be stored in: {} and application logs in: \
+                {}. Logs of the background Defguard service responsible for managing VPN \
+                connections at the network level will be stored in: {}.",
+                data_dir.display(),
+                log_dir.display(),
                 service::config::DEFAULT_LOG_DIR
             );
             tauri::async_runtime::block_on(startup(app_handle));

src-tauri/src/enterprise/provisioning/mod.rs

@@ -83,13 +83,16 @@ pub async fn handle_client_initialization(app_handle: &AppHandle) -> Option<Prov
                     .unwrap_or_else(|_| "UNDEFINED DATA DIRECTORY".into());
                 match try_get_provisioning_config(&data_dir) {
                     Some(config) => {
-                        info!("Provisioning config found in {data_dir:?}: {config:?}");
+                        info!(
+                            "Provisioning config found in {}: {config:?}",
+                            data_dir.display()
+                        );
                         return Some(config);
                     }
                     None => {
                         debug!(
-                            "Provisioning config not found in {data_dir:?}. Proceeding with normal \
-                            startup."
+                            "Provisioning config not found in {}. Proceeding with normal startup.",
+                            data_dir.display()
                         );
                     }
                 }

src-tauri/src/lib.rs

@@ -39,6 +39,8 @@ pub const MIN_PROXY_VERSION: Version = Version::new(1, 6, 0);
 pub const CLIENT_VERSION_HEADER: &str = "defguard-client-version";
 pub const CLIENT_PLATFORM_HEADER: &str = "defguard-client-platform";
 pub const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+// Must be without ".log" suffix!
+pub const LOG_FILENAME: &str = "defguard-client";
 // This must match tauri.bundle.identifier from tauri.conf.json.
 const BUNDLE_IDENTIFIER: &str = "net.defguard";
 // Returns the path to the user's data directory.
@@ -54,7 +56,10 @@ pub fn app_data_dir() -> Option<PathBuf> {
 pub fn set_perms(path: &Path) {
     let perms = if path.is_dir() { 0o700 } else { 0o600 };
     if let Err(err) = set_permissions(path, Permissions::from_mode(perms)) {
-        warn!("Failed to set permissions on path {path:?}: {err}");
+        warn!(
+            "Failed to set permissions on path {}: {err}",
+            path.display()
+        );
     }
 }
 

src-tauri/src/log_watcher/global_log_watcher.rs

@@ -17,6 +17,7 @@ use chrono::NaiveDate;
 use chrono::{DateTime, NaiveDateTime, TimeZone, Utc};
 use regex::Regex;
 use tauri::{async_runtime::JoinHandle, AppHandle, Emitter, Manager};
+use tokio::time::sleep;
 use tokio_util::sync::CancellationToken;
 use tracing::Level;
 
@@ -26,6 +27,7 @@ use crate::{
     appstate::AppState,
     error::Error,
     log_watcher::{LogLine, LogLineFields, LogSource, LogWatcherError},
+    LOG_FILENAME,
 };
 #[cfg(not(target_os = "macos"))]
 use crate::{log_watcher::extract_timestamp, utils::get_service_log_dir};
@@ -125,42 +127,24 @@ impl LogDirs {
 
     #[cfg(not(target_os = "macos"))]
     fn get_current_service_file(&self) -> Result<File, LogWatcherError> {
-        trace!(
-            "Opening service log file: {:?}",
-            self.current_service_log_file
-        );
         match &self.current_service_log_file {
             Some(path) => {
+                trace!("Opening service log file: {}", path.display());
                 let file = File::open(path)?;
-                trace!(
-                    "Successfully opened service log file at {:?}",
-                    self.current_service_log_file
-                );
+                trace!("Successfully opened service log file at {}", path.display());
                 Ok(file)
             }
-            None => Err(LogWatcherError::LogPathError(format!(
-                "Couldn't find service log file at: {:?}",
-                self.current_service_log_file
-            ))),
+            None => Err(LogWatcherError::LogPathError(
+                "Service log file not defined".to_string(),
+            )),
         }
     }
 
     fn get_client_file(&self) -> Result<File, LogWatcherError> {
-        trace!(
-            "Opening the log file for the client, using directory: {}",
-            self.client_log_dir.display()
-        );
-        let dir_str = self
-            .client_log_dir
-            .to_str()
-            .ok_or(LogWatcherError::LogPathError(format!(
-                "Couldn't convert the client log directory path ({}) to a string slice",
-                self.client_log_dir.display()
-            )))?;
-        let path = format!("{dir_str}/defguard-client.log");
-        trace!("Constructed client log file path: {path}");
+        let path = self.client_log_dir.join(format!("{LOG_FILENAME}.log"));
+        trace!("Constructed client log file path: {}", path.display());
         let file = File::open(&path)?;
-        trace!("Client log file at {path:?} opened successfully");
+        trace!("Client log file at {} opened successfully", path.display());
         Ok(file)
     }
 
@@ -243,7 +227,7 @@ impl GlobalLogWatcher {
                 self.log_dirs.client_log_dir.display()
             );
             // Wait for logs to appear.
-            tokio::time::sleep(DELAY).await;
+            sleep(DELAY).await;
             return Ok(());
         }
         debug!("Log files are available, starting to read lines.");
@@ -335,7 +319,7 @@ impl GlobalLogWatcher {
                 parsed_lines.clear();
             }
             trace!("Sleeping for {DELAY:?} seconds before reading again");
-            tokio::time::sleep(DELAY).await;
+            sleep(DELAY).await;
         }
 
         Ok(())
@@ -368,7 +352,7 @@ impl GlobalLogWatcher {
                 self.log_dirs.vpn_extension_log_dir.display()
             );
             // Wait for logs to appear.
-            tokio::time::sleep(DELAY).await;
+            sleep(DELAY).await;
             return Ok(());
         }
         debug!("Log files are available, starting to read lines.");
@@ -450,7 +434,7 @@ impl GlobalLogWatcher {
                 parsed_lines.clear();
             }
             trace!("Sleeping for {DELAY:?} seconds before reading again");
-            tokio::time::sleep(DELAY).await;
+            sleep(DELAY).await;
         }
 
         Ok(())