X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Flogger.rs;h=f1534933792949a41318c3b80e0cc1847cbf63f4;hb=973636bd2ab2ba35fb8b9703f1d5d0e72f069cdc;hp=f8fc1eda1080e6bf3ad3aed723ac553d6bf5daa3;hpb=09714e6fe286b8cd5863b616748362b76c2fbdf0;p=rust-lightning diff --git a/lightning/src/util/logger.rs b/lightning/src/util/logger.rs index f8fc1eda..f1534933 100644 --- a/lightning/src/util/logger.rs +++ b/lightning/src/util/logger.rs @@ -14,8 +14,15 @@ //! 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; 6] = ["GOSSIP", "TRACE", "DEBUG", "INFO", "WARN", "ERROR"]; @@ -90,6 +97,11 @@ impl Level { pub struct Record<'a> { /// The verbosity level of the message. pub level: Level, + /// The node id of the peer pertaining to the logged record. + 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>, @@ -111,11 +123,17 @@ pub struct Record<'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: &'static str, file: &'static str, line: u32) -> Record<'a> { + pub fn new( + level: Level, peer_id: Option, channel_id: Option, + args: fmt::Arguments<'a>, module_path: &'static str, file: &'static str, line: u32 + ) -> Record<'a> { Record { level, + peer_id, + channel_id, #[cfg(not(c_bindings))] args, #[cfg(c_bindings)] @@ -129,14 +147,62 @@ impl<'a> 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`]. +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> { @@ -148,11 +214,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() { @@ -191,6 +279,41 @@ mod tests { 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);