Add LoggerScope

Author: joostjager

lightning/src/chain/chainmonitor.rs

@@ -53,7 +53,7 @@ use crate::sync::{Mutex, MutexGuard, RwLock, RwLockReadGuard};
 use crate::types::features::{InitFeatures, NodeFeatures};
 use crate::util::async_poll::{MaybeSend, MaybeSync};
 use crate::util::errors::APIError;
-use crate::util::logger::{Logger, WithContext};
+use crate::util::logger::{Logger, LoggerScope, WithContext};
 use crate::util::native_async::FutureSpawner;
 use crate::util::persist::{KVStore, MonitorName, MonitorUpdatingPersisterAsync};
 #[cfg(peer_storage)]
@@ -1426,6 +1426,8 @@ where
 			Some(monitor_state) => {
 				let monitor = &monitor_state.monitor;
 				let logger = WithChannelMonitor::from(&self.logger, &monitor, None);
+				let _scope = LoggerScope::new(&logger);
+
 				log_trace!(
 					logger,
 					"Updating ChannelMonitor to id {} for channel {}",

lightning/src/chain/channelmonitor.rs

@@ -3815,6 +3815,12 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 					}
 				}));
 			}
+
+			log_info_tls!(
+				"Recording counterparty fulfillment of HTLC id {:?} with preimage {} in channel monitor",
+				*claimed_htlc_id,
+				*claimed_preimage
+			);
 			self.counterparty_fulfilled_htlcs.insert(*claimed_htlc_id, *claimed_preimage);
 		}
 

lightning/src/util/logger.rs

@@ -15,6 +15,7 @@
 
 use bitcoin::secp256k1::PublicKey;
 
+use core::cell::RefCell;
 use core::cmp;
 use core::fmt;
 use core::ops::Deref;
@@ -261,15 +262,60 @@ impl<T: fmt::Display, I: core::iter::Iterator<Item = T> + Clone> fmt::Display fo
 	}
 }
 
+thread_local! {
+	pub(crate) static TLS_LOGGER: RefCell<Option<&'static dyn Logger>> = RefCell::new(None);
+}
+
+pub struct LoggerScope<'a> {
+	_marker: std::marker::PhantomData<&'a ()>,
+}
+
+impl<'a> LoggerScope<'a> {
+	pub fn new<L: Logger + 'a>(logger: &'a L) -> Self {
+		TLS_LOGGER.with(|cell| {
+			let mut borrow = cell.borrow_mut();
+
+			// Prevent nested scopes
+			if borrow.is_some() {
+				panic!("LoggerScope already active in this thread");
+			}
+
+			// Transmute is safe in practice because the RAII pattern ensures:
+			// - The TLS logger reference is only used while the guard exists.
+			// - The guard cannot outlive the logger (thanks to PhantomData<'a>).
+			let logger_ref: &dyn Logger = logger;
+			let logger_ref_static: &'static dyn Logger = unsafe { std::mem::transmute(logger_ref) };
+
+			*borrow = Some(logger_ref_static);
+		});
+		LoggerScope { _marker: std::marker::PhantomData }
+	}
+}
+
+impl<'a> Drop for LoggerScope<'a> {
+	fn drop(&mut self) {
+		TLS_LOGGER.with(|cell| {
+			*cell.borrow_mut() = None;
+		});
+	}
+}
+
 #[cfg(test)]
 mod tests {
 	use crate::ln::types::ChannelId;
 	use crate::sync::Arc;
 	use crate::types::payment::PaymentHash;
-	use crate::util::logger::{Level, Logger, WithContext};
+	use crate::util::logger::{Level, Logger, LoggerScope, WithContext};
 	use crate::util::test_utils::TestLogger;
 	use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
 
+	#[test]
+	fn logger_scope() {
+		let logger = TestLogger::new();
+		let _scope = LoggerScope::new(&logger);
+		log_info_tls!("Info")
+	}
+
 	#[test]
 	fn test_level_show() {
 		assert_eq!("INFO", Level::Info.to_string());

lightning/src/util/macro_logger.rs

@@ -203,6 +203,17 @@ macro_rules! log_info {
 	)
 }
 
+#[macro_export]
+macro_rules! log_info_tls {
+	($($arg:tt)+) => {
+		$crate::util::logger::TLS_LOGGER.with(|cell| {
+			if let Some(logger) = &*cell.borrow() {
+				log_info!(logger, $($arg)*);
+			}
+		})
+	};
+}
+
 /// Log at the `DEBUG` level.
 #[macro_export]
 macro_rules! log_debug {

lightning/src/util/persist.rs

@@ -35,7 +35,7 @@ use crate::ln::types::ChannelId;
 use crate::sign::{ecdsa::EcdsaChannelSigner, EntropySource, SignerProvider};
 use crate::sync::Mutex;
 use crate::util::async_poll::{dummy_waker, AsyncResult, MaybeSend, MaybeSync};
-use crate::util::logger::Logger;
+use crate::util::logger::{Logger, LoggerScope};
 use crate::util::native_async::FutureSpawner;
 use crate::util::ser::{Readable, ReadableArgs, Writeable};
 use crate::util::wakers::Notifier;
@@ -1063,6 +1063,7 @@ where
 				Err(err) => return Err(err),
 			};
 
+			// let _scope = LoggerScope::new(&*self.logger); // DOES NOT WORK
 			monitor
 				.update_monitor(&update, &self.broadcaster, &self.fee_estimator, &self.logger)
 				.map_err(|e| {