feat(custom): forward logs to a custom logger

* Add support for user-provided custom logger to
  write logs to, allowing users to provide any logger
  that implements LogWriter
* Add test to cover this use case, implementing Log-
  Writer for the mock, in-memory MockLogger.

Author: enigbe

src/builder.rs

@@ -19,7 +19,7 @@ use crate::io::sqlite_store::SqliteStore;
 use crate::io::utils::{read_node_metrics, write_node_metrics};
 use crate::io::vss_store::VssStore;
 use crate::liquidity::LiquiditySource;
-use crate::logger::{log_error, log_info, LdkLogger, Logger};
+use crate::logger::{log_error, log_info, LdkLogger, LogWriter, Logger};
 use crate::message_handler::NodeCustomMessageHandler;
 use crate::payment::store::PaymentStore;
 use crate::peer_store::PeerStore;
@@ -113,6 +113,7 @@ impl Default for LiquiditySourceConfig {
 enum LogWriterConfig {
 	File(FilesystemLoggerConfig),
 	Log(LogFacadeLoggerConfig),
+	Custom(Arc<dyn LogWriter + Send + Sync>),
 }
 
 impl Default for LogWriterConfig {
@@ -328,6 +329,12 @@ impl NodeBuilder {
 		self
 	}
 
+	/// Configures the [`Node`] instance to write logs to the provided custom log writer.
+	pub fn set_custom_logger(&mut self, log_writer: Arc<dyn LogWriter + Send + Sync>) -> &mut Self {
+		self.log_writer_config = Some(LogWriterConfig::Custom(log_writer));
+		self
+	}
+
 	/// Sets the Bitcoin network used.
 	pub fn set_network(&mut self, network: Network) -> &mut Self {
 		self.config.network = network;
@@ -648,6 +655,11 @@ impl ArcedNodeBuilder {
 		self.inner.write().unwrap().set_log_facade_logger(lf_config);
 	}
 
+	/// Configures the [`Node`] instance to write logs to the provided custom log writer.
+	pub fn set_custom_logger(&self, log_writer: Arc<dyn LogWriter + Send + Sync>) {
+		self.inner.write().unwrap().set_custom_logger(log_writer);
+	}
+
 	/// Sets the Bitcoin network used.
 	pub fn set_network(&self, network: Network) {
 		self.inner.write().unwrap().set_network(network);
@@ -1274,6 +1286,10 @@ fn setup_logger(config: &LogWriterConfig) -> Result<Arc<Logger>, BuildError> {
 			Logger::new_log_facade(log_facade_logger_config.level)
 				.map_err(|_| BuildError::LoggerSetupFailed)?,
 		)),
+		LogWriterConfig::Custom(custom_log_writer) => Ok(Arc::new(
+			Logger::new_custom_writer(custom_log_writer.clone())
+				.map_err(|_| BuildError::LoggerSetupFailed)?,
+		)),
 	}
 }
 

src/logger.rs

@@ -13,9 +13,11 @@ pub use lightning::util::logger::Level as LdkLevel;
 use chrono::Utc;
 use log::{debug, error, info, trace, warn};
 
+use std::fmt::Debug;
 use std::fs;
 use std::io::Write;
 use std::path::Path;
+use std::sync::Arc;
 
 /// A unit of logging output with Metadata to enable filtering Module_path,
 /// file, line to inform on log's source.
@@ -43,26 +45,31 @@ impl<'a> From<Record<'a>> for LogRecord {
 
 /// LogWriter trait encapsulating the operations required of a
 /// logger's writer.
-pub trait LogWriter: Send + Sync {
+pub trait LogWriter: Send + Sync + Debug {
 	/// Log the record.
 	fn log(&self, record: LogRecord);
 }
 
+#[derive(Debug)]
 pub(crate) struct FilesystemLogger {
 	file_path: String,
 	level: LdkLevel,
 }
 
+#[derive(Debug)]
 pub(crate) struct LogFacadeLogger {
 	level: LdkLevel,
 }
 
 /// Defines a writer for [`Logger`].
+#[derive(Debug)]
 pub(crate) enum Writer {
 	/// Writes logs to the file system.
 	FileWriter(FilesystemLogger),
 	/// Forwards logs to the `log` facade.
 	LogFacadeWriter(LogFacadeLogger),
+	/// Forwards logs to custom writer.
+	CustomWriter(Arc<dyn LogWriter + Send + Sync>),
 }
 
 impl LogWriter for Writer {
@@ -99,6 +106,7 @@ impl LogWriter for Writer {
 				LdkLevel::Warn => warn!("{}", log),
 				LdkLevel::Error => error!("{}", log),
 			},
+			Writer::CustomWriter(custom_logger) => custom_logger.log(record),
 		}
 	}
 }
@@ -134,6 +142,10 @@ impl Logger {
 
 		Ok(Self { writer: Writer::LogFacadeWriter(log_facade_writer) })
 	}
+
+	pub fn new_custom_writer(log_writer: Arc<dyn LogWriter + Send + Sync>) -> Result<Self, ()> {
+		Ok(Self { writer: Writer::CustomWriter(log_writer) })
+	}
 }
 
 impl LdkLogger for Logger {

tests/common/mod.rs

@@ -8,12 +8,13 @@
 #![cfg(any(test, cln_test, vss_test))]
 #![allow(dead_code)]
 
+use chrono::Utc;
 use ldk_node::config::{Config, EsploraSyncConfig};
 use ldk_node::io::sqlite_store::SqliteStore;
 use ldk_node::payment::{PaymentDirection, PaymentKind, PaymentStatus};
 use ldk_node::{
-	Builder, Event, FilesystemLoggerConfig, LightningBalance, LogFacadeLoggerConfig, Node,
-	NodeError, PendingSweepBalance,
+	Builder, Event, FilesystemLoggerConfig, LightningBalance, LogFacadeLoggerConfig, LogRecord,
+	LogWriter, Node, NodeError, PendingSweepBalance,
 };
 
 use lightning::ln::msgs::SocketAddress;
@@ -254,9 +255,11 @@ pub(crate) enum TestChainSource<'a> {
 pub(crate) enum TestLogWriter {
 	File(FilesystemLoggerConfig),
 	LogFacade(LogFacadeLoggerConfig),
+	Custom(Arc<dyn LogWriter + Send + Sync>),
 }
 
 /// Simple in-memory mock `log` logger for tests.
+#[derive(Debug)]
 pub(crate) struct MockLogger {
 	logs: Arc<Mutex<Vec<String>>>,
 }
@@ -271,9 +274,18 @@ impl MockLogger {
 	}
 }
 
+/// [`MockLogger`] as `log` logger - destination for [`Writer::LogFacadeWriter`]
+/// to write logs to.
+///
+/// [`Writer::LogFacadeWriter`]: ldk_node::logger::Writer::LogFacadeWriter
 impl Log for MockLogger {
 	fn log(&self, record: &log::Record) {
-		let message = format!("[{}] {}", record.level(), record.args());
+		let message = format!(
+			"{} [{}] {}",
+			Utc::now().format("%Y-%m-%d %H:%M:%S"),
+			record.level(),
+			record.args()
+		);
 		self.logs.lock().unwrap().push(message);
 	}
 
@@ -284,6 +296,22 @@ impl Log for MockLogger {
 	fn flush(&self) {}
 }
 
+/// [`MockLogger`] as custom logger - a destination for [`Writer::CustomWriter`]
+/// to write logs to.
+///
+/// [`Writer::CustomWriter`]: ldk_node::logger::Writer::CustomWriter
+impl LogWriter for MockLogger {
+	fn log(&self, record: LogRecord) {
+		let message = format!(
+			"{} [{}] {}",
+			Utc::now().format("%Y-%m-%d %H:%M:%S"),
+			record.level,
+			record.args
+		);
+		self.logs.lock().unwrap().push(message);
+	}
+}
+
 pub(crate) fn init_mock_logger(level: LevelFilter) -> Arc<MockLogger> {
 	let logger = Arc::new(MockLogger::new());
 	log::set_boxed_logger(Box::new(logger.clone())).unwrap();
@@ -357,6 +385,9 @@ pub(crate) fn setup_node(
 		TestLogWriter::LogFacade(lf_config) => {
 			builder.set_log_facade_logger(lf_config);
 		},
+		TestLogWriter::Custom(log_writer) => {
+			builder.set_custom_logger(log_writer);
+		},
 	}
 
 	if let Some(seed) = seed_bytes {

tests/integration_tests_rust.rs

@@ -791,7 +791,10 @@ fn simple_bolt12_send_receive() {
 fn generate_bip21_uri() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let log_writer = TestLogWriter::File(FilesystemLoggerConfig::default());
+
+	// Setup custom logger.
+	let mock_logger = init_mock_logger(log::LevelFilter::Trace);
+	let log_writer = TestLogWriter::Custom(mock_logger.clone());
 	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);
 
 	let address_a = node_a.onchain_payment().new_address().unwrap();
@@ -828,13 +831,16 @@ fn generate_bip21_uri() {
 		},
 		Err(e) => panic!("Failed to generate URI: {:?}", e),
 	}
+
+	assert!(mock_logger.retrieve_logs().last().unwrap().contains("Invoice created: lnbcrt"));
 }
 
 #[test]
 fn unified_qr_send_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
 
+	// Setup `log` facade logger.
 	let mock_logger = init_mock_logger(log::LevelFilter::Trace);
 	let log_writer = TestLogWriter::LogFacade(LogFacadeLoggerConfig { level: LdkLevel::Trace });
 	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false, log_writer);