mylog 0.1.41

A minimal Rust crate providing 3 lightweight logging macros to simplify writing log messages to a file.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! This module implements three macros facilitating logging.

use std::fs::{self, DirEntry, OpenOptions};
use std::io::Write;
use std::path::PathBuf;
use std::env;
use std::time::{SystemTime, Duration};
use rayon::prelude::*;

use crate::utils::*;

const LOG_FILE_NAME: &str = "logs.txt";

/// Init the logs folder path by setting an environment variable called *_MYLOG_DIR_*
pub fn init(folder_path: String, file_size: String, duration: String) -> Result<(), String> {
    let folder_path = PathBuf::from(folder_path);

    if !fs::exists(&folder_path).unwrap_or(false) {
        fs::create_dir_all(&folder_path)
            .map_err(|e| format!(
                "Failed when try to create the folder : {:?}\n{}", folder_path, e
            ))?;
    }

    write_gitignore(&folder_path).map_err(|e| format!("Failed to write the .gitignore in the folder '{:?}' : {}", folder_path, e))?;

    let size_in_bytes = parse_file_size(&file_size)
        .ok_or(format!("Invalid file_size : {}", file_size))?;
    let duration_in_secs = parse_duration(&duration)
        .ok_or(format!("Invalid duration : {}", duration))?;

    unsafe {
        env::set_var("MYLOG_DIR", &folder_path);
    }

    let entries: Vec<DirEntry> = fs::read_dir(&folder_path)
        .map_err(|e| format!(
            "Failed when try to read the directory : {:?}\n{}", folder_path, e
        ))?
        .flatten()
        .collect();

    let now = SystemTime::now();

    entries.par_iter().for_each(|entry| {
        let path = entry.path();
        
        match path.extension().and_then(|e| e.to_str()).unwrap_or_default() {
            "txt" => {
                if let Ok(metadata) = fs::metadata(&path) {
                    if metadata.len() >= size_in_bytes {
                        let _ = compress_to_zip(&path, &folder_path);
                    }
                }
            }
            "zip" => {
                if let Ok(metadata) = fs::metadata(&path) {
                    if let Ok(modified) = metadata.modified() {
                        if now.duration_since(modified).unwrap_or(Duration::ZERO).as_secs() > duration_in_secs
                        {
                            let _ = fs::remove_file(path);
                        }
                    }
                }
            }
            _ => {}
        }
    });
    Ok(())
}

/// Get the path to the log file
pub fn get_log_path() -> PathBuf {
    let mylog_dir = env::var("MYLOG_DIR").unwrap_or(String::new());
    let mut path = PathBuf::from(mylog_dir);
    path.push(LOG_FILE_NAME);
    path
}

/// Write the content in argument in the __ at the root of the project.
pub fn write_log(content: String) {
    match OpenOptions::new()
        .append(true)
        .create(true)
        .open(get_log_path())
    {
        Ok(mut file) => {
            let _ = file.write_all(content.as_bytes());
        }
        Err(error) => {
            println!("Error when try to write log : {:?}", error);
        }
    }
}

#[macro_export]
/// Format the content in argument like the macro "format!()" <br>
/// and adding the current Timestamp and the level of to the log file.<br>
/// This has the following format : \[_TIMESTAMP_] \[INFO] \[_file_:_line_] \[_content_]
macro_rules! info {
    ($format_str:expr) => {{
        let msg = format!("[{}] [INFO] [{}:{}] : {}\n", $crate::utils::get_time(), file!(), line!(), $format_str);
        $crate::logs::write_log(msg);
    }};
    ($format_str:expr, $($arg:tt)*) => {{
        let msg = format!("[{}] [INFO] [{}:{}] : {}\n", $crate::utils::get_time(), file!(), line!(), format!($format_str, $($arg)*));
        $crate::logs::write_log(msg);
    }};
}

#[macro_export]
/// Format the content in argument like the macro "format!()" <br>
/// and adding the current Timestamp and the level of to the log file.<br>
/// This has the following format : \[_TIMESTAMP_] \[WARNING] \[_file_:_line_] \[_content_]
macro_rules! warn {
    ($format_str:expr) => {{
        let msg = format!("[{}] [WARNING] [{}:{}] : {}\n", $crate::utils::get_time(), file!(), line!(), $format_str);
        $crate::logs::write_log(msg);
    }};
    ($format_str:expr, $($arg:tt)*) => {{
        let msg = format!("[{}] [WARNING] [{}:{}] : {}\n", $crate::utils::get_time(), file!(), line!(), format!($format_str, $($arg)*));
        $crate::logs::write_log(msg);
    }};
}

#[macro_export]
/// Format the content in argument like the macro "format!()" <br>
/// and adding the current Timestamp and the level of to the log file.<br>
/// This has the following format : \[_TIMESTAMP_] \[ERROR] \[_file_:_line_] \[_content_]
macro_rules! error {
    ($format_str:expr) => {{
        let msg = format!("[{}] [ERROR] [{}:{}] : {}\n", $crate::utils::get_time(), file!(), line!(), $format_str);
        $crate::logs::write_log(msg);
    }};
    ($format_str:expr, $($arg:tt)*) => {{
        let msg = format!("[{}] [ERROR] [{}:{}] : {}\n", $crate::utils::get_time(), file!(), line!(), format!($format_str, $($arg)*));
        $crate::logs::write_log(msg);
    }};
}