X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Flogger.rs;h=e48cefaa0443ff9c0a1f731a35fdc73fba57d17b;hb=fb3a86f498f971dc01fdd58b166031793ff1bc1a;hp=2717effb209d94750b1965a28c64a856647f3d80;hpb=4d6c26248d85abe9a3c8aeefe31b4ebafd3b5bee;p=rust-lightning diff --git a/lightning/src/util/logger.rs b/lightning/src/util/logger.rs index 2717effb..e48cefaa 100644 --- a/lightning/src/util/logger.rs +++ b/lightning/src/util/logger.rs @@ -14,14 +14,23 @@ //! 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; +use core::ops::Deref; + +use crate::ln::ChannelId; +#[cfg(c_bindings)] +use crate::prelude::*; // Needed for String -static LOG_LEVEL_NAMES: [&'static str; 5] = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR"]; +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,50 +87,129 @@ impl Level { /// Returns the most verbose logging level. #[inline] pub fn max() -> Level { - Level::Trace + Level::Gossip } } +macro_rules! impl_record { + ($($args: lifetime)?, $($nonstruct_args: lifetime)?) => { /// 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)] -pub struct Record<'a> { +#[derive(Clone, Debug)] +pub struct Record<$($args)?> { /// The verbosity level of the message. pub level: Level, + /// The node id of the peer pertaining to the logged record. + /// + /// Note that in some cases a [`Self::channel_id`] may be filled in but this may still be + /// `None`, depending on if the peer information is readily available in LDK when the log is + /// generated. + pub peer_id: Option, + /// The channel id of the channel pertaining to the logged record. May be a temporary id before + /// the channel has been funded. + pub channel_id: Option, + #[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, } -impl<'a> Record<'a> { +impl<$($args)?> Record<$($args)?> { /// 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<$($nonstruct_args)?>( + level: Level, peer_id: Option, channel_id: Option, + args: fmt::Arguments<'a>, module_path: &'static str, file: &'static str, line: u32 + ) -> Record<$($args)?> { Record { level, + peer_id, + channel_id, + #[cfg(not(c_bindings))] args, + #[cfg(c_bindings)] + args: format!("{}", args), module_path, file, - line + line, } } } +} } +#[cfg(not(c_bindings))] +impl_record!('a, ); +#[cfg(c_bindings)] +impl_record!(, 'a); -/// A trait encapsulating the operations required of a logger +/// A trait encapsulating the operations required of a logger. pub trait Logger { - /// Logs the `Record` - fn log(&self, record: &Record); + /// Logs the [`Record`]. + fn log(&self, record: Record); +} + +/// Adds relevant context to a [`Record`] before passing it to the wrapped [`Logger`]. +/// +/// This is not exported to bindings users as lifetimes are problematic and there's little reason +/// for this to be used downstream anyway. +pub struct WithContext<'a, L: Deref> where L::Target: Logger { + /// The logger to delegate to after adding context to the record. + logger: &'a L, + /// The node id of the peer pertaining to the logged record. + peer_id: Option, + /// The channel id of the channel pertaining to the logged record. + channel_id: Option, +} + +impl<'a, L: Deref> Logger for WithContext<'a, L> where L::Target: Logger { + fn log(&self, mut record: Record) { + if self.peer_id.is_some() { + record.peer_id = self.peer_id + }; + if self.channel_id.is_some() { + record.channel_id = self.channel_id; + } + self.logger.log(record) + } +} + +impl<'a, L: Deref> WithContext<'a, L> where L::Target: Logger { + /// Wraps the given logger, providing additional context to any logged records. + pub fn from(logger: &'a L, peer_id: Option, channel_id: Option) -> Self { + WithContext { + logger, + peer_id, + channel_id, + } + } +} + +/// 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. -/// (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 #[doc(hidden)] pub struct DebugBytes<'a>(pub &'a [u8]); impl<'a> core::fmt::Display for DebugBytes<'a> { @@ -133,11 +221,33 @@ 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 bitcoin::secp256k1::{PublicKey, SecretKey, Secp256k1}; + use crate::ln::ChannelId; + use crate::util::logger::{Logger, Level, WithContext}; + use crate::util::test_utils::TestLogger; + use crate::sync::Arc; #[test] fn test_level_show() { @@ -147,11 +257,11 @@ mod tests { } struct WrapperLog { - logger: Arc + logger: Arc } impl WrapperLog { - fn new(logger: Arc) -> WrapperLog { + fn new(logger: Arc) -> WrapperLog { WrapperLog { logger, } @@ -163,18 +273,54 @@ 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); - let logger : Arc = Arc::new(logger); + logger.enable(Level::Gossip); + let logger : Arc = Arc::new(logger); let wrapper = WrapperLog::new(Arc::clone(&logger)); wrapper.call_macros(); } + #[test] + fn test_logging_with_context() { + let logger = &TestLogger::new(); + let secp_ctx = Secp256k1::new(); + let pk = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); + let context_logger = WithContext::from(&logger, Some(pk), Some(ChannelId([0; 32]))); + log_error!(context_logger, "This is an error"); + log_warn!(context_logger, "This is an error"); + log_debug!(context_logger, "This is an error"); + log_trace!(context_logger, "This is an error"); + log_gossip!(context_logger, "This is an error"); + log_info!(context_logger, "This is an error"); + logger.assert_log_context_contains( + "lightning::util::logger::tests", Some(pk), Some(ChannelId([0;32])), 6 + ); + } + + #[test] + fn test_logging_with_multiple_wrapped_context() { + let logger = &TestLogger::new(); + let secp_ctx = Secp256k1::new(); + let pk = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()); + let context_logger = &WithContext::from(&logger, None, Some(ChannelId([0; 32]))); + let full_context_logger = WithContext::from(&context_logger, Some(pk), None); + log_error!(full_context_logger, "This is an error"); + log_warn!(full_context_logger, "This is an error"); + log_debug!(full_context_logger, "This is an error"); + log_trace!(full_context_logger, "This is an error"); + log_gossip!(full_context_logger, "This is an error"); + log_info!(full_context_logger, "This is an error"); + logger.assert_log_context_contains( + "lightning::util::logger::tests", Some(pk), Some(ChannelId([0;32])), 6 + ); + } + #[test] fn test_log_ordering() { assert!(Level::Error > Level::Warn); @@ -189,7 +335,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); @@ -204,5 +353,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); } }