]> git.bitcoin.ninja Git - rust-lightning/blob - lightning/src/util/logger.rs
01b024065b29240284f507fd4bb3f9501641fecb
[rust-lightning] / lightning / src / util / logger.rs
1 // Pruned copy of crate rust log, without global logger
2 // https://github.com/rust-lang-nursery/log #7a60286
3 //
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
8 // licenses.
9
10 //! Log traits live here, which are called throughout the library to provide useful information for
11 //! debugging purposes.
12 //!
13 //! There is currently 2 ways to filter log messages. First one, by using compilation features, e.g "max_level_off".
14 //! The second one, client-side by implementing check against Record Level field.
15 //! Each module may have its own Logger or share one.
16
17 use core::cmp;
18 use core::fmt;
19
20 static LOG_LEVEL_NAMES: [&'static str; 5] = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR"];
21
22 /// An enum representing the available verbosity levels of the logger.
23 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
24 pub enum Level {
25         /// Designates very low priority, often extremely verbose, information
26         Trace,
27         /// Designates lower priority information
28         Debug,
29         /// Designates useful information
30         Info,
31         /// Designates hazardous situations
32         Warn,
33         /// Designates very serious errors
34         Error,
35 }
36
37 impl PartialOrd for Level {
38         #[inline]
39         fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
40                 Some(self.cmp(other))
41         }
42
43         #[inline]
44         fn lt(&self, other: &Level) -> bool {
45                 (*self as usize) < *other as usize
46         }
47
48         #[inline]
49         fn le(&self, other: &Level) -> bool {
50                 *self as usize <= *other as usize
51         }
52
53         #[inline]
54         fn gt(&self, other: &Level) -> bool {
55                 *self as usize > *other as usize
56         }
57
58         #[inline]
59         fn ge(&self, other: &Level) -> bool {
60                 *self as usize >= *other as usize
61         }
62 }
63
64 impl Ord for Level {
65         #[inline]
66         fn cmp(&self, other: &Level) -> cmp::Ordering {
67                 (*self as usize).cmp(&(*other as usize))
68         }
69 }
70
71 impl fmt::Display for Level {
72         fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
73                 fmt.pad(LOG_LEVEL_NAMES[*self as usize])
74         }
75 }
76
77 impl Level {
78         /// Returns the most verbose logging level.
79         #[inline]
80         pub fn max() -> Level {
81                 Level::Trace
82         }
83 }
84
85 /// A Record, unit of logging output with Metadata to enable filtering
86 /// Module_path, file, line to inform on log's source
87 /// (C-not exported) - we convert to a const char* instead
88 #[derive(Clone,Debug)]
89 pub struct Record<'a> {
90         /// The verbosity level of the message.
91         pub level: Level,
92         /// The message body.
93         pub args: fmt::Arguments<'a>,
94         /// The module path of the message.
95         pub module_path: &'a str,
96         /// The source file containing the message.
97         pub file: &'a str,
98         /// The line containing the message.
99         pub line: u32,
100 }
101
102 impl<'a> Record<'a> {
103         /// Returns a new Record.
104         /// (C-not exported) as fmt can't be used in C
105         #[inline]
106         pub fn new(level: Level, args: fmt::Arguments<'a>, module_path: &'a str, file: &'a str, line: u32) -> Record<'a> {
107                 Record {
108                         level,
109                         args,
110                         module_path,
111                         file,
112                         line
113                 }
114         }
115 }
116
117 /// A trait encapsulating the operations required of a logger
118 pub trait Logger {
119         /// Logs the `Record`
120         fn log(&self, record: &Record);
121 }
122
123 /// Wrapper for logging byte slices in hex format.
124 #[doc(hidden)]
125 pub struct DebugBytes<'a>(pub &'a [u8]);
126 impl<'a> core::fmt::Display for DebugBytes<'a> {
127         fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
128                 for i in self.0 {
129                         write!(f, "{:02x}", i)?;
130                 }
131                 Ok(())
132         }
133 }
134
135 #[cfg(test)]
136 mod tests {
137         use util::logger::{Logger, Level};
138         use util::test_utils::TestLogger;
139         use sync::Arc;
140
141         #[test]
142         fn test_level_show() {
143                 assert_eq!("INFO", Level::Info.to_string());
144                 assert_eq!("ERROR", Level::Error.to_string());
145                 assert_ne!("WARN", Level::Error.to_string());
146         }
147
148         struct WrapperLog {
149                 logger: Arc<Logger>
150         }
151
152         impl WrapperLog {
153                 fn new(logger: Arc<Logger>) -> WrapperLog {
154                         WrapperLog {
155                                 logger,
156                         }
157                 }
158
159                 fn call_macros(&self) {
160                         log_error!(self.logger, "This is an error");
161                         log_warn!(self.logger, "This is a warning");
162                         log_info!(self.logger, "This is an info");
163                         log_debug!(self.logger, "This is a debug");
164                         log_trace!(self.logger, "This is a trace");
165                 }
166         }
167
168         #[test]
169         fn test_logging_macros() {
170                 let mut logger = TestLogger::new();
171                 logger.enable(Level::Trace);
172                 let logger : Arc<Logger> = Arc::new(logger);
173                 let wrapper = WrapperLog::new(Arc::clone(&logger));
174                 wrapper.call_macros();
175         }
176
177         #[test]
178         fn test_log_ordering() {
179                 assert!(Level::Error > Level::Warn);
180                 assert!(Level::Error >= Level::Warn);
181                 assert!(Level::Error >= Level::Error);
182                 assert!(Level::Warn > Level::Info);
183                 assert!(Level::Warn >= Level::Info);
184                 assert!(Level::Warn >= Level::Warn);
185                 assert!(Level::Info > Level::Debug);
186                 assert!(Level::Info >= Level::Debug);
187                 assert!(Level::Info >= Level::Info);
188                 assert!(Level::Debug > Level::Trace);
189                 assert!(Level::Debug >= Level::Trace);
190                 assert!(Level::Debug >= Level::Debug);
191                 assert!(Level::Trace >= Level::Trace);
192
193                 assert!(Level::Error <= Level::Error);
194                 assert!(Level::Warn < Level::Error);
195                 assert!(Level::Warn <= Level::Error);
196                 assert!(Level::Warn <= Level::Warn);
197                 assert!(Level::Info < Level::Warn);
198                 assert!(Level::Info <= Level::Warn);
199                 assert!(Level::Info <= Level::Info);
200                 assert!(Level::Debug < Level::Info);
201                 assert!(Level::Debug <= Level::Info);
202                 assert!(Level::Debug <= Level::Debug);
203                 assert!(Level::Trace < Level::Debug);
204                 assert!(Level::Trace <= Level::Debug);
205                 assert!(Level::Trace <= Level::Trace);
206         }
207 }