feat: add separate log files for debug and trace

Author: helton

src/files/config.rs

@@ -1,5 +1,7 @@
+use log::LevelFilter;
 use serde::{Deserialize, Serialize};
 use std::error::Error;
+use std::str::FromStr;
 
 use crate::files::variables::AppConfig;
 use crate::serialization::{parse_json, save_json};
@@ -11,21 +13,84 @@ pub struct Root {
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Logs {
-    pub level: String,
-    pub strategy: String,
+    #[serde(default)]
+    pub enabled: bool,
+    pub level: Level,
+    pub strategy: Strategy,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "lowercase")]
+pub enum Level {
+    Trace,
+    Debug,
+    Info,
+    Warn,
+    Error,
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum Strategy {
+    Truncate,
+    Append,
+}
+
+impl Logs {
+    pub fn new() -> Self {
+        Self {
+            enabled: false,
+            level: Level::Info,
+            strategy: Strategy::Append,
+        }
+    }
+}
+
+impl Level {
+    pub fn to_level_filter(&self) -> LevelFilter {
+        match self {
+            Level::Info => LevelFilter::Info,
+            Level::Warn => LevelFilter::Warn,
+            Level::Debug => LevelFilter::Debug,
+            Level::Trace => LevelFilter::Trace,
+            _ => LevelFilter::Info,
+        }
+    }
+}
+
+impl FromStr for Level {
+    type Err = ();
+
+    fn from_str(input: &str) -> Result<Level, Self::Err> {
+        match input {
+            "trace" => Ok(Level::Trace),
+            "debug" => Ok(Level::Debug),
+            "info" => Ok(Level::Info),
+            "warn" => Ok(Level::Warn),
+            "error" => Ok(Level::Error),
+            _ => Err(()),
+        }
+    }
+}
+
+impl FromStr for Strategy {
+    type Err = ();
+
+    fn from_str(input: &str) -> Result<Strategy, Self::Err> {
+        match input {
+            "truncate" => Ok(Strategy::Truncate),
+            "append" => Ok(Strategy::Append),
+            _ => Err(()),
+        }
+    }
 }
 
 pub fn get_config() -> Result<Root, Box<dyn Error>> {
     let config = AppConfig::new();
     if config.config_path().exists() {
         parse_json(&config.config_path())
     } else {
-        let root = Root {
-            logs: Logs {
-                level: "info".to_owned(),
-                strategy: "append".to_owned(),
-            },
-        };
+        let root = Root { logs: Logs::new() };
         save_json(&root, &config.config_path())?;
         Ok(root)
     }

src/logging.rs

@@ -1,4 +1,5 @@
-use crate::files::config::get_config;
+use crate::files::config::Strategy::{Append, Truncate};
+use crate::files::config::{get_config, Logs};
 use crate::files::variables::AppConfig;
 use chrono::Local;
 use log::{Level, LevelFilter, Log, Metadata, Record};
@@ -8,20 +9,7 @@ use std::io::Write;
 use std::sync::{Arc, Mutex};
 
 pub fn setup_logger() -> Result<(), Box<dyn Error>> {
-    let (log_level, log_strategy) = if let Ok(config) = get_config() {
-        (
-            match config.logs.level.to_lowercase().as_str() {
-                "info" => LevelFilter::Info,
-                "warn" => LevelFilter::Warn,
-                "debug" => LevelFilter::Debug,
-                "trace" => LevelFilter::Trace,
-                _ => LevelFilter::Error,
-            },
-            config.logs.strategy,
-        )
-    } else {
-        (LevelFilter::Info, "truncate".to_string())
-    };
+    let logs_config = get_config().map_or_else(|_| Logs::new(), |config| config.logs);
 
     let config = AppConfig::new();
     let log_file_path = config.logs_path();
@@ -35,25 +23,27 @@ pub fn setup_logger() -> Result<(), Box<dyn Error>> {
     let file = OpenOptions::new()
         .create(true)
         .write(true)
-        .truncate(log_strategy == "truncate")
-        .append(log_strategy == "append")
+        .truncate(logs_config.strategy == Truncate)
+        .append(logs_config.strategy == Append)
         .open(log_file_path)?;
 
     let file = Arc::new(Mutex::new(file));
 
     // Set the logger
     log::set_boxed_logger(Box::new(Logger {
         file: file.clone(),
-        level: log_level,
+        level: logs_config.level.to_level_filter(),
+        enabled: logs_config.enabled,
     }))?;
-    log::set_max_level(log_level);
+    log::set_max_level(logs_config.level.to_level_filter());
 
     Ok(())
 }
 
 struct Logger {
     file: Arc<Mutex<File>>,
     level: LevelFilter,
+    enabled: bool,
 }
 
 impl Log for Logger {
@@ -82,29 +72,19 @@ impl Log for Logger {
             record.args()
         );
 
-        if self.level <= LevelFilter::Debug
-            && (record.level() == Level::Info
-                || record.level() == Level::Warn
-                || record.level() == Level::Error)
-        {
+        if self.enabled {
             let mut file = self.file.lock().unwrap();
             writeln!(file, "{}", log_line).unwrap();
         }
 
         match record.level() {
-            Level::Trace | Level::Debug => {
-                let mut file = self.file.lock().unwrap();
-                writeln!(file, "{}", log_line).unwrap();
-            }
-            Level::Info => {
-                println!("{}", record.args());
-            }
-            Level::Warn => {
+            Level::Info | Level::Warn => {
                 println!("{}", record.args());
             }
             Level::Error => {
                 eprintln!("{}", record.args());
             }
+            _ => ()
         }
     }