X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Flogger.rs;h=e48cefaa0443ff9c0a1f731a35fdc73fba57d17b;hb=fb3a86f498f971dc01fdd58b166031793ff1bc1a;hp=dbca9b785e85dfbaf3c68253e7e47b91225c6bdc;hpb=3141630f78a0f1ec7ef374ede95a21e4e64213f5;p=rust-lightning diff --git a/lightning/src/util/logger.rs b/lightning/src/util/logger.rs index dbca9b78..e48cefaa 100644 --- a/lightning/src/util/logger.rs +++ b/lightning/src/util/logger.rs @@ -18,7 +18,9 @@ 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 @@ -89,12 +91,23 @@ impl Level { } } +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 #[derive(Clone, Debug)] -pub struct Record<'a> { +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>, @@ -107,21 +120,21 @@ pub struct Record<'a> { 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> { +impl<$($args)?> Record<$($args)?> { /// Returns a new Record. /// /// 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<$($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)] @@ -129,16 +142,55 @@ impl<'a> Record<'a> { module_path, file, line, - #[cfg(c_bindings)] - _phantom: core::marker::PhantomData, } } } +} } +#[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. @@ -191,7 +243,9 @@ impl + Clone> fmt::Display fo #[cfg(test)] mod tests { - use crate::util::logger::{Logger, Level}; + 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; @@ -203,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, } @@ -227,11 +281,46 @@ mod tests { fn test_logging_macros() { let mut logger = TestLogger::new(); logger.enable(Level::Gossip); - let logger : Arc = Arc::new(logger); + 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);