src/logger/log

src/logger/log_entry.rs

Lines

100.00 %

Functions

100.00 %

Regions

100.00 %


//
// File Name:    log_entry.rs
// Directory:    src/logger
// Project Name: flogging
//
// Copyright (C) 2025 Bradley Willcott
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
// This library (crate) is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This library (crate) is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this library (crate).  If not, see <https://www.gnu.org/licenses/>.
//

//!
//! # Log Entry
//!

use chrono::{DateTime, Local};
use std::{fmt, time::Instant};
use super::Level;

///
/// Used to provide relevant information about each log entry.
///
#[derive(Debug)]
pub struct LogEntry {
    pub(crate) timestamp: DateTime<Local>,
    pub(crate) mod_path: String,
    ///
    /// This is the name of the function/method inside which this
    /// log entry was generated.
    ///
    pub(crate) fn_name: String,
    pub(crate) level: Level,
    pub(crate) message: String,
}

impl fmt::Display for LogEntry {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{} : {}->{} ({}) {}",
            self.timestamp, self.mod_path, self.fn_name, self.level, self.message
        )
    }
}

#[allow(unused)]
impl LogEntry {
    pub(crate) fn create(level: Level, fn_name: String, message: String) -> LogEntry {
        LogEntry {
            timestamp: Local::now(),
            mod_path: String::new(),
            fn_name,
            level,
            message,
        }
    }

    pub(crate) fn fn_name(&self) -> String {
        self.fn_name.clone()
    }

    pub(crate) fn level(&self) -> Level {
        self.level
    }

    pub(crate) fn message(&self) -> String {
        self.message.clone()
    }

    pub(crate) fn mod_path(&self) -> String {
        self.mod_path.clone()
    }

    pub(crate) fn set_fn_name(&mut self, fn_name: String) {
        self.fn_name = fn_name.clone();
    }

    pub(crate) fn set_mod_path(&mut self, mod_path: String) {
        self.mod_path = mod_path.clone();
    }

    pub(crate) fn timestamp(&self) -> DateTime<Local> {
        self.timestamp
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn to_string() {
        let mut log_entry =
            LogEntry::create(Level::INFO, "to_string".to_string(), "message".to_string());

        log_entry.set_mod_path(module_path!().to_owned());
        println!("\nlog_entry: {log_entry}\n");

        assert_eq!(log_entry.level(), Level::INFO);
        assert_eq!(log_entry.message(), "message".to_string());
        assert_eq!(log_entry.fn_name(), "to_string".to_string());
        assert_eq!(log_entry.mod_path(), module_path!());
        assert!(log_entry.timestamp().timestamp() > 0);

        log_entry.set_fn_name("fn_name".to_owned());
        assert_eq!(log_entry.fn_name(), "fn_name".to_string());
    }
}

Line	Count	Source (jump to first uncovered line)
1		//
2		// File Name: log_entry.rs
3		// Directory: src/logger
4		// Project Name: flogging
5		//
6		// Copyright (C) 2025 Bradley Willcott
7		//
8		// SPDX-License-Identifier: GPL-3.0-or-later
9		//
10		// This library (crate) is free software: you can redistribute it and/or modify
11		// it under the terms of the GNU General Public License as published by
12		// the Free Software Foundation, either version 3 of the License, or
13		// (at your option) any later version.
14		//
15		// This library (crate) is distributed in the hope that it will be useful,
16		// but WITHOUT ANY WARRANTY; without even the implied warranty of
17		// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18		// GNU General Public License for more details.
19		//
20		// You should have received a copy of the GNU General Public License
21		// along with this library (crate). If not, see <https://www.gnu.org/licenses/>.
22		//
23
24		//!
25		//! # Log Entry
26		//!
27
28		use chrono::{DateTime, Local};
29		use std::{fmt, time::Instant};
30		use super::Level;
31
32		///
33		/// Used to provide relevant information about each log entry.
34		///
35		#[derive(Debug)]
36		pub struct LogEntry {
37		pub(crate) timestamp: DateTime<Local>,
38		pub(crate) mod_path: String,
39		///
40		/// This is the name of the function/method inside which this
41		/// log entry was generated.
42		///
43		pub(crate) fn_name: String,
44		pub(crate) level: Level,
45		pub(crate) message: String,
46		}
47
48		impl fmt::Display for LogEntry {
49	1	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
50	1	write!(
51	1	f,
52	1	"{} : {}->{} ({}) {}",
53		self.timestamp, self.mod_path, self.fn_name, self.level, self.message
54		)
55	1	}
56		}
57
58		#[allow(unused)]
59		impl LogEntry {
60	109	pub(crate) fn create(level: Level, fn_name: String, message: String) -> LogEntry {
61	109	LogEntry {
62	109	timestamp: Local::now(),
63	109	mod_path: String::new(),
64	109	fn_name,
65	109	level,
66	109	message,
67	109	}
68	109	}
69
70	2	pub(crate) fn fn_name(&self) -> String {
71	2	self.fn_name.clone()
72	2	}
73
74	9	pub(crate) fn level(&self) -> Level {
75	9	self.level
76	9	}
77
78	5	pub(crate) fn message(&self) -> String {
79	5	self.message.clone()
80	5	}
81
82	1	pub(crate) fn mod_path(&self) -> String {
83	1	self.mod_path.clone()
84	1	}
85
86	1	pub(crate) fn set_fn_name(&mut self, fn_name: String) {
87	1	self.fn_name = fn_name.clone();
88	1	}
89
90	105	pub(crate) fn set_mod_path(&mut self, mod_path: String) {
91	105	self.mod_path = mod_path.clone();
92	105	}
93
94	1	pub(crate) fn timestamp(&self) -> DateTime<Local> {
95	1	self.timestamp
96	1	}
97		}
98
99		#[cfg(test)]
100		mod tests {
101		use super::*;
102
103		#[test]
104	1	fn to_string() {
105	1	let mut log_entry =
106	1	LogEntry::create(Level::INFO, "to_string".to_string(), "message".to_string());
107
108	1	log_entry.set_mod_path(module_path!().to_owned());
109	1	println!("\nlog_entry: {log_entry}\n");
110
111	1	assert_eq!(log_entry.level(), Level::INFO);
112	1	assert_eq!(log_entry.message(), "message".to_string());
113	1	assert_eq!(log_entry.fn_name(), "to_string".to_string());
114	1	assert_eq!(log_entry.mod_path(), module_path!());
115	1	assert!(log_entry.timestamp().timestamp() > 0);
116
117	1	log_entry.set_fn_name("fn_name".to_owned());
118	1	assert_eq!(log_entry.fn_name(), "fn_name".to_string());
119	1	}
120		}