use core::fmt;
use core::ops::Deref;
-use crate::ln::ChannelId;
+use crate::ln::types::ChannelId;
+use crate::ln::PaymentHash;
#[cfg(c_bindings)]
use crate::prelude::*; // Needed for String
pub file: &'static str,
/// The line containing the message.
pub line: u32,
+ /// The payment hash.
+ ///
+ /// Note that this is only filled in for logs pertaining to a specific payment, and will be
+ /// `None` for logs which are not directly related to a payment.
+ pub payment_hash: Option<PaymentHash>,
}
impl<$($args)?> Record<$($args)?> {
#[inline]
pub fn new<$($nonstruct_args)?>(
level: Level, peer_id: Option<PublicKey>, channel_id: Option<ChannelId>,
- args: fmt::Arguments<'a>, module_path: &'static str, file: &'static str, line: u32
+ args: fmt::Arguments<'a>, module_path: &'static str, file: &'static str, line: u32,
+ payment_hash: Option<PaymentHash>
) -> Record<$($args)?> {
Record {
level,
module_path,
file,
line,
+ payment_hash,
}
}
}
}
/// 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,
peer_id: Option<PublicKey>,
/// The channel id of the channel pertaining to the logged record.
channel_id: Option<ChannelId>,
+ /// The payment hash of the payment pertaining to the logged record.
+ payment_hash: Option<PaymentHash>
}
impl<'a, L: Deref> Logger for WithContext<'a, L> where L::Target: Logger {
if self.channel_id.is_some() {
record.channel_id = self.channel_id;
}
+ if self.payment_hash.is_some() {
+ record.payment_hash = self.payment_hash;
+ }
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<PublicKey>, channel_id: Option<ChannelId>) -> Self {
+ pub fn from(logger: &'a L, peer_id: Option<PublicKey>, channel_id: Option<ChannelId>, payment_hash: Option<PaymentHash>) -> Self {
WithContext {
logger,
peer_id,
channel_id,
+ payment_hash,
}
}
}
#[cfg(test)]
mod tests {
use bitcoin::secp256k1::{PublicKey, SecretKey, Secp256k1};
- use crate::ln::ChannelId;
+ use crate::ln::types::ChannelId;
+ use crate::ln::PaymentHash;
use crate::util::logger::{Logger, Level, WithContext};
use crate::util::test_utils::TestLogger;
use crate::sync::Arc;
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])));
+ let payment_hash = PaymentHash([0; 32]);
+ let context_logger = WithContext::from(&logger, Some(pk), Some(ChannelId([0; 32])), Some(payment_hash));
log_error!(context_logger, "This is an error");
log_warn!(context_logger, "This is an error");
log_debug!(context_logger, "This is an error");
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);
+ let payment_hash = PaymentHash([0; 32]);
+ let context_logger = &WithContext::from(&logger, None, Some(ChannelId([0; 32])), Some(payment_hash));
+ let full_context_logger = WithContext::from(&context_logger, Some(pk), None, 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");