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.
* Fix setting log's global logger twice.
* Revert the renaming of LogLevel to LdkLevel.

Author: enigbe

bindings/ldk_node.udl

@@ -25,7 +25,7 @@ dictionary EsploraSyncConfig {
 	u64 fee_rate_cache_update_interval_secs;
 };
 
-enum LdkLevel {
+enum LogLevel {
 	"Gossip",
 	"Trace",
 	"Debug",
@@ -36,11 +36,11 @@ enum LdkLevel {
 
 dictionary FilesystemLoggerConfig {
 	string log_file_path;
-	LdkLevel level;
+	LogLevel level;
 };
 
 dictionary LogFacadeLoggerConfig {
-	LdkLevel level;
+	LogLevel level;
 };
 
 interface Builder {
@@ -594,7 +594,7 @@ dictionary NodeAnnouncementInfo {
 };
 
 dictionary LogRecord {
-	LdkLevel level;
+	LogLevel level;
 	string args;
 	string module_path;
 	u32 line;

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);
@@ -1285,6 +1297,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/config.rs

@@ -7,7 +7,7 @@
 
 //! Objects for configuring the node.
 
-use crate::logger::LdkLevel;
+use crate::logger::LogLevel;
 use crate::payment::SendingParameters;
 
 use lightning::ln::msgs::SocketAddress;
@@ -30,7 +30,7 @@ const DEFAULT_FEE_RATE_CACHE_UPDATE_INTERVAL_SECS: u64 = 60 * 10;
 const DEFAULT_PROBING_LIQUIDITY_LIMIT_MULTIPLIER: u64 = 3;
 const DEFAULT_ANCHOR_PER_CHANNEL_RESERVE_SATS: u64 = 25_000;
 const DEFAULT_LOG_FILE_PATH: &'static str = "ldk_node.log";
-const DEFAULT_LOG_LEVEL: LdkLevel = LdkLevel::Debug;
+const DEFAULT_LOG_LEVEL: LogLevel = LogLevel::Debug;
 
 // The 'stop gap' parameter used by BDK's wallet sync. This seems to configure the threshold
 // number of derivation indexes after which BDK stops looking for new scripts belonging to the wallet.
@@ -438,14 +438,14 @@ pub struct FilesystemLoggerConfig {
 	/// directory, i.e. [`Config::storage_dir_path`], is preferred.
 	pub log_file_path: String,
 	/// This specifies the log level.
-	pub level: LdkLevel,
+	pub level: LogLevel,
 }
 
 /// Configuration options for logging to the `log` facade.
 #[derive(Debug, Clone)]
 pub struct LogFacadeLoggerConfig {
 	/// This specifies the log level.
-	pub level: LdkLevel,
+	pub level: LogLevel,
 }
 
 impl Default for FilesystemLoggerConfig {

src/lib.rs

@@ -112,7 +112,7 @@ pub use event::Event;
 pub use io::utils::generate_entropy_mnemonic;
 
 pub use config::{FilesystemLoggerConfig, LogFacadeLoggerConfig};
-pub use logger::{LdkLevel, LogRecord, LogWriter};
+pub use logger::{LogLevel, LogRecord, LogWriter};
 
 #[cfg(feature = "uniffi")]
 use uniffi_types::*;

src/logger.rs

@@ -8,20 +8,22 @@
 pub(crate) use lightning::util::logger::{Logger as LdkLogger, Record};
 pub(crate) use lightning::{log_bytes, log_debug, log_error, log_info, log_trace};
 
-pub use lightning::util::logger::Level as LdkLevel;
+pub use lightning::util::logger::Level as LogLevel;
 
 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.
 pub struct LogRecord {
 	/// The verbosity level of the message.
-	pub level: LdkLevel,
+	pub level: LogLevel,
 	/// The message body.
 	pub args: String,
 	/// The module path of the message.
@@ -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,
+	level: LogLevel,
 }
 
+#[derive(Debug)]
 pub(crate) struct LogFacadeLogger {
-	level: LdkLevel,
+	level: LogLevel,
 }
 
 /// 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 {
@@ -92,13 +99,14 @@ impl LogWriter for Writer {
 					.expect("Failed to write to log file")
 			},
 			Writer::LogFacadeWriter(log_facade_logger) => match log_facade_logger.level {
-				LdkLevel::Gossip => trace!("{}", log),
-				LdkLevel::Trace => trace!("{}", log),
-				LdkLevel::Debug => debug!("{}", log),
-				LdkLevel::Info => info!("{}", log),
-				LdkLevel::Warn => warn!("{}", log),
-				LdkLevel::Error => error!("{}", log),
+				LogLevel::Gossip => trace!("{}", log),
+				LogLevel::Trace => trace!("{}", log),
+				LogLevel::Debug => debug!("{}", log),
+				LogLevel::Info => info!("{}", log),
+				LogLevel::Warn => warn!("{}", log),
+				LogLevel::Error => error!("{}", log),
 			},
+			Writer::CustomWriter(custom_logger) => custom_logger.log(record),
 		}
 	}
 }
@@ -111,7 +119,7 @@ pub(crate) struct Logger {
 impl Logger {
 	/// Creates a new logger with a filesystem writer. The parameters to this function
 	/// are the path to the log file, and the log level.
-	pub fn new_fs_writer(log_file_path: String, level: LdkLevel) -> Result<Self, ()> {
+	pub fn new_fs_writer(log_file_path: String, level: LogLevel) -> Result<Self, ()> {
 		if let Some(parent_dir) = Path::new(&log_file_path).parent() {
 			fs::create_dir_all(parent_dir)
 				.map_err(|e| eprintln!("ERROR: Failed to create log parent directory: {}", e))?;
@@ -129,11 +137,15 @@ impl Logger {
 		Ok(Self { writer: Writer::FileWriter(fs_writer) })
 	}
 
-	pub fn new_log_facade(level: LdkLevel) -> Result<Self, ()> {
+	pub fn new_log_facade(level: LogLevel) -> Result<Self, ()> {
 		let log_facade_writer = LogFacadeLogger { level };
 
 		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, CustomTlvRecord, Event, FilesystemLoggerConfig, LightningBalance,
-	LogFacadeLoggerConfig, Node, NodeError, PendingSweepBalance,
+	LogFacadeLoggerConfig, LogRecord, LogWriter, Node, NodeError, PendingSweepBalance,
 };
 
 use lightning::ln::msgs::SocketAddress;
@@ -257,9 +258,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>>>,
 }
@@ -274,9 +277,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);
 	}
 
@@ -287,13 +299,34 @@ impl Log for MockLogger {
 	fn flush(&self) {}
 }
 
-pub(crate) fn init_mock_logger(level: LevelFilter) -> Arc<MockLogger> {
+/// [`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_log_logger(level: LevelFilter) -> Arc<MockLogger> {
 	let logger = Arc::new(MockLogger::new());
 	log::set_boxed_logger(Box::new(logger.clone())).unwrap();
 	log::set_max_level(level);
 	logger
 }
 
+pub(crate) fn init_custom_logger() -> Arc<MockLogger> {
+	let logger = Arc::new(MockLogger::new());
+	logger
+}
+
 macro_rules! setup_builder {
 	($builder: ident, $config: expr) => {
 		#[cfg(feature = "uniffi")]
@@ -360,6 +393,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

@@ -9,14 +9,15 @@ mod common;
 
 use common::{
 	do_channel_full_cycle, expect_channel_ready_event, expect_event, expect_payment_received_event,
-	expect_payment_successful_event, generate_blocks_and_wait, init_mock_logger, open_channel,
-	premine_and_distribute_funds, random_config, setup_bitcoind_and_electrsd, setup_builder,
-	setup_node, setup_two_nodes, wait_for_tx, TestChainSource, TestLogWriter, TestSyncStore,
+	expect_payment_successful_event, generate_blocks_and_wait, init_custom_logger, init_log_logger,
+	open_channel, premine_and_distribute_funds, random_config, setup_bitcoind_and_electrsd,
+	setup_builder, setup_node, setup_two_nodes, wait_for_tx, TestChainSource, TestLogWriter,
+	TestSyncStore,
 };
 
 use ldk_node::config::{EsploraSyncConfig, FilesystemLoggerConfig};
 use ldk_node::payment::{PaymentKind, QrPaymentResult, SendingParameters};
-use ldk_node::LdkLevel;
+use ldk_node::LogLevel;
 use ldk_node::{Builder, Event, LogFacadeLoggerConfig, NodeError};
 
 use lightning::ln::channelmanager::PaymentId;
@@ -801,7 +802,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_custom_logger();
+	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();
@@ -838,15 +842,20 @@ fn generate_bip21_uri() {
 		},
 		Err(e) => panic!("Failed to generate URI: {:?}", e),
 	}
+
+	let logs = mock_logger.retrieve_logs();
+	let last_log_entry = logs.last().unwrap();
+	assert!(last_log_entry.contains("[INFO] Invoice created:"));
 }
 
 #[test]
 fn unified_qr_send_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
 
-	let mock_logger = init_mock_logger(log::LevelFilter::Trace);
-	let log_writer = TestLogWriter::LogFacade(LogFacadeLoggerConfig { level: LdkLevel::Trace });
+	// Setup `log` facade logger.
+	let mock_logger = init_log_logger(log::LevelFilter::Trace);
+	let log_writer = TestLogWriter::LogFacade(LogFacadeLoggerConfig { level: LogLevel::Trace });
 	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();