X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Flogger.rs;h=dbca9b785e85dfbaf3c68253e7e47b91225c6bdc;hb=a61746246c369dada11469c25dd739f4807c042b;hp=01b024065b29240284f507fd4bb3f9501641fecb;hpb=a3a4e614276cbfe7c2fbb9eeb39d32982f1e6bb0;p=rust-lightning diff --git a/lightning/src/util/logger.rs b/lightning/src/util/logger.rs index 01b02406..dbca9b78 100644 --- a/lightning/src/util/logger.rs +++ b/lightning/src/util/logger.rs @@ -14,14 +14,21 @@ //! The second one, client-side by implementing check against Record Level field. //! Each module may have its own Logger or share one. +use bitcoin::secp256k1::PublicKey; + use core::cmp; use core::fmt; -static LOG_LEVEL_NAMES: [&'static str; 5] = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR"]; +#[cfg(c_bindings)] +use crate::prelude::*; // Needed for String + +static LOG_LEVEL_NAMES: [&'static str; 6] = ["GOSSIP", "TRACE", "DEBUG", "INFO", "WARN", "ERROR"]; /// An enum representing the available verbosity levels of the logger. #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)] pub enum Level { + /// Designates extremely verbose information, including gossip-induced messages + Gossip, /// Designates very low priority, often extremely verbose, information Trace, /// Designates lower priority information @@ -78,38 +85,52 @@ impl Level { /// Returns the most verbose logging level. #[inline] pub fn max() -> Level { - Level::Trace + Level::Gossip } } /// A Record, unit of logging output with Metadata to enable filtering /// Module_path, file, line to inform on log's source -/// (C-not exported) - we convert to a const char* instead -#[derive(Clone,Debug)] +#[derive(Clone, Debug)] pub struct Record<'a> { /// The verbosity level of the message. pub level: Level, + #[cfg(not(c_bindings))] /// The message body. pub args: fmt::Arguments<'a>, + #[cfg(c_bindings)] + /// The message body. + pub args: String, /// The module path of the message. - pub module_path: &'a str, + pub module_path: &'static str, /// The source file containing the message. - pub file: &'a str, + pub file: &'static str, /// The line containing the message. pub line: u32, + + #[cfg(c_bindings)] + /// We don't actually use the lifetime parameter in C bindings (as there is no good way to + /// communicate a lifetime to a C, or worse, Java user). + _phantom: core::marker::PhantomData<&'a ()>, } impl<'a> Record<'a> { /// Returns a new Record. - /// (C-not exported) as fmt can't be used in C + /// + /// This is not exported to bindings users as fmt can't be used in C #[inline] - pub fn new(level: Level, args: fmt::Arguments<'a>, module_path: &'a str, file: &'a str, line: u32) -> Record<'a> { + pub fn new(level: Level, args: fmt::Arguments<'a>, module_path: &'static str, file: &'static str, line: u32) -> Record<'a> { Record { level, + #[cfg(not(c_bindings))] args, + #[cfg(c_bindings)] + args: format!("{}", args), module_path, file, - line + line, + #[cfg(c_bindings)] + _phantom: core::marker::PhantomData, } } } @@ -120,7 +141,23 @@ pub trait Logger { fn log(&self, record: &Record); } +/// Wrapper for logging a [`PublicKey`] in hex format. +/// +/// This is not exported to bindings users as fmt can't be used in C +#[doc(hidden)] +pub struct DebugPubKey<'a>(pub &'a PublicKey); +impl<'a> core::fmt::Display for DebugPubKey<'a> { + fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> { + for i in self.0.serialize().iter() { + write!(f, "{:02x}", i)?; + } + Ok(()) + } +} + /// Wrapper for logging byte slices in hex format. +/// +/// This is not exported to bindings users as fmt can't be used in C #[doc(hidden)] pub struct DebugBytes<'a>(pub &'a [u8]); impl<'a> core::fmt::Display for DebugBytes<'a> { @@ -132,11 +169,31 @@ impl<'a> core::fmt::Display for DebugBytes<'a> { } } +/// Wrapper for logging `Iterator`s. +/// +/// This is not exported to bindings users as fmt can't be used in C +#[doc(hidden)] +pub struct DebugIter + Clone>(pub I); +impl + Clone> fmt::Display for DebugIter { + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + write!(f, "[")?; + let mut iter = self.0.clone(); + if let Some(item) = iter.next() { + write!(f, "{}", item)?; + } + while let Some(item) = iter.next() { + write!(f, ", {}", item)?; + } + write!(f, "]")?; + Ok(()) + } +} + #[cfg(test)] mod tests { - use util::logger::{Logger, Level}; - use util::test_utils::TestLogger; - use sync::Arc; + use crate::util::logger::{Logger, Level}; + use crate::util::test_utils::TestLogger; + use crate::sync::Arc; #[test] fn test_level_show() { @@ -162,13 +219,14 @@ mod tests { log_info!(self.logger, "This is an info"); log_debug!(self.logger, "This is a debug"); log_trace!(self.logger, "This is a trace"); + log_gossip!(self.logger, "This is a gossip"); } } #[test] fn test_logging_macros() { let mut logger = TestLogger::new(); - logger.enable(Level::Trace); + logger.enable(Level::Gossip); let logger : Arc = Arc::new(logger); let wrapper = WrapperLog::new(Arc::clone(&logger)); wrapper.call_macros(); @@ -188,7 +246,10 @@ mod tests { assert!(Level::Debug > Level::Trace); assert!(Level::Debug >= Level::Trace); assert!(Level::Debug >= Level::Debug); + assert!(Level::Trace > Level::Gossip); + assert!(Level::Trace >= Level::Gossip); assert!(Level::Trace >= Level::Trace); + assert!(Level::Gossip >= Level::Gossip); assert!(Level::Error <= Level::Error); assert!(Level::Warn < Level::Error); @@ -203,5 +264,8 @@ mod tests { assert!(Level::Trace < Level::Debug); assert!(Level::Trace <= Level::Debug); assert!(Level::Trace <= Level::Trace); + assert!(Level::Gossip < Level::Trace); + assert!(Level::Gossip <= Level::Trace); + assert!(Level::Gossip <= Level::Gossip); } }