feat(facade): forward logs to log facade

- modify tests to forward logs to mock in-memory
  `log` logger
- correct "Forwards" spelling error

Author: enigbe

Cargo.toml

@@ -80,6 +80,7 @@ libc = "0.2"
 uniffi = { version = "0.27.3", features = ["build"], optional = true }
 serde = { version = "1.0.210", default-features = false, features = ["std", "derive"] }
 serde_json = { version = "1.0.128", default-features = false, features = ["std"] }
+log = { version = "0.4.22", features = ["std"]}
 
 vss-client = "0.3"
 prost = { version = "0.11.6", default-features = false}

bindings/ldk_node.udl

@@ -39,6 +39,10 @@ dictionary FilesystemLoggerConfig {
 	LdkLevel level;
 };
 
+dictionary LogFacadeLoggerConfig {
+	LdkLevel level;
+};
+
 interface Builder {
 	constructor();
 	[Name=from_config]
@@ -54,6 +58,7 @@ interface Builder {
 	void set_liquidity_source_lsps2(SocketAddress address, PublicKey node_id, string? token);
 	void set_storage_dir_path(string storage_dir_path);
 	void set_filesystem_logger(FilesystemLoggerConfig fs_config);
+	void set_log_facade_logger(LogFacadeLoggerConfig lf_config);
 	void set_network(Network network);
 	[Throws=BuildError]
 	void set_listening_addresses(sequence<SocketAddress> listening_addresses);

src/builder.rs

@@ -7,7 +7,8 @@
 
 use crate::chain::{ChainSource, DEFAULT_ESPLORA_SERVER_URL};
 use crate::config::{
-	default_user_config, Config, EsploraSyncConfig, FilesystemLoggerConfig, WALLET_KEYS_SEED_LEN,
+	default_user_config, Config, EsploraSyncConfig, FilesystemLoggerConfig, LogFacadeLoggerConfig,
+	WALLET_KEYS_SEED_LEN,
 };
 
 use crate::connection::ConnectionManager;
@@ -111,6 +112,7 @@ impl Default for LiquiditySourceConfig {
 #[derive(Debug)]
 enum LogWriterConfig {
 	File(FilesystemLoggerConfig),
+	Log(LogFacadeLoggerConfig),
 }
 
 impl Default for LogWriterConfig {
@@ -320,6 +322,12 @@ impl NodeBuilder {
 		self
 	}
 
+	/// Configures the [`Node`] instance to write logs to the `log` facade.
+	pub fn set_log_facade_logger(&mut self, lf_config: LogFacadeLoggerConfig) -> &mut Self {
+		self.log_writer_config = Some(LogWriterConfig::Log(lf_config));
+		self
+	}
+
 	/// Sets the Bitcoin network used.
 	pub fn set_network(&mut self, network: Network) -> &mut Self {
 		self.config.network = network;
@@ -635,6 +643,11 @@ impl ArcedNodeBuilder {
 		self.inner.write().unwrap().set_filesystem_logger(fs_config);
 	}
 
+	/// Configures the [`Node`] instance to write logs to the `log` facade.
+	pub fn set_log_facade_logger(&self, lf_config: LogFacadeLoggerConfig) {
+		self.inner.write().unwrap().set_log_facade_logger(lf_config);
+	}
+
 	/// Sets the Bitcoin network used.
 	pub fn set_network(&self, network: Network) {
 		self.inner.write().unwrap().set_network(network);
@@ -1268,6 +1281,10 @@ fn setup_logger(config: &LogWriterConfig) -> Result<Arc<Logger>, BuildError> {
 					.map_err(|_| BuildError::LoggerSetupFailed)?,
 			))
 		},
+		LogWriterConfig::Log(log_facade_logger_config) => Ok(Arc::new(
+			Logger::new_log_facade(log_facade_logger_config.level)
+				.map_err(|_| BuildError::LoggerSetupFailed)?,
+		)),
 	}
 }
 

src/config.rs

@@ -430,7 +430,7 @@ impl From<MaxDustHTLCExposure> for LdkMaxDustHTLCExposure {
 }
 
 /// Configuration options for logging to the filesystem.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct FilesystemLoggerConfig {
 	/// The log file path.
 	///
@@ -441,6 +441,13 @@ pub struct FilesystemLoggerConfig {
 	pub level: LdkLevel,
 }
 
+/// Configuration options for logging to the `log` facade.
+#[derive(Debug, Clone)]
+pub struct LogFacadeLoggerConfig {
+	/// This specifies the log level.
+	pub level: LdkLevel,
+}
+
 impl Default for FilesystemLoggerConfig {
 	fn default() -> Self {
 		let log_file_path = format!("{}/{}", DEFAULT_STORAGE_DIR_PATH, DEFAULT_LOG_FILE_PATH);

src/lib.rs

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

src/logger.rs

@@ -11,6 +11,7 @@ pub(crate) use lightning::{log_bytes, log_debug, log_error, log_info, log_trace}
 pub use lightning::util::logger::Level as LdkLevel;
 
 use chrono::Utc;
+use log::{debug, error, info, trace, warn};
 
 use std::fs;
 use std::io::Write;
@@ -52,10 +53,16 @@ pub(crate) struct FilesystemLogger {
 	level: LdkLevel,
 }
 
+pub(crate) struct LogFacadeLogger {
+	level: LdkLevel,
+}
+
 /// Defines a writer for [`Logger`].
 pub(crate) enum Writer {
 	/// Writes logs to the file system.
 	FileWriter(FilesystemLogger),
+	/// Forwards logs to the `log` facade.
+	LogFacadeWriter(LogFacadeLogger),
 }
 
 impl LogWriter for Writer {
@@ -84,6 +91,14 @@ impl LogWriter for Writer {
 					.write_all(log.as_bytes())
 					.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),
+			},
 		}
 	}
 }
@@ -113,6 +128,12 @@ impl Logger {
 
 		Ok(Self { writer: Writer::FileWriter(fs_writer) })
 	}
+
+	pub fn new_log_facade(level: LdkLevel) -> Result<Self, ()> {
+		let log_facade_writer = LogFacadeLogger { level };
+
+		Ok(Self { writer: Writer::LogFacadeWriter(log_facade_writer) })
+	}
 }
 
 impl LdkLogger for Logger {

tests/common/mod.rs

@@ -12,7 +12,8 @@ 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, LightningBalance, Node, NodeError, PendingSweepBalance,
+	Builder, CustomTlvRecord, Event, FilesystemLoggerConfig, LightningBalance,
+	LogFacadeLoggerConfig, Node, NodeError, PendingSweepBalance,
 };
 
 use lightning::ln::msgs::SocketAddress;
@@ -39,9 +40,11 @@ use electrum_client::ElectrumApi;
 use rand::distributions::Alphanumeric;
 use rand::{thread_rng, Rng};
 
+use log::{LevelFilter, Log};
+
 use std::env;
 use std::path::PathBuf;
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, Mutex, RwLock};
 use std::time::Duration;
 
 macro_rules! expect_event {
@@ -250,6 +253,47 @@ pub(crate) enum TestChainSource<'a> {
 	BitcoindRpc(&'a BitcoinD),
 }
 
+#[derive(Clone)]
+pub(crate) enum TestLogWriter {
+	File(FilesystemLoggerConfig),
+	LogFacade(LogFacadeLoggerConfig),
+}
+
+/// Simple in-memory mock `log` logger for tests.
+pub(crate) struct MockLogger {
+	logs: Arc<Mutex<Vec<String>>>,
+}
+
+impl MockLogger {
+	pub fn new() -> Self {
+		Self { logs: Arc::new(Mutex::new(Vec::new())) }
+	}
+
+	pub fn retrieve_logs(&self) -> Vec<String> {
+		self.logs.lock().unwrap().clone()
+	}
+}
+
+impl Log for MockLogger {
+	fn log(&self, record: &log::Record) {
+		let message = format!("[{}] {}", record.level(), record.args());
+		self.logs.lock().unwrap().push(message);
+	}
+
+	fn enabled(&self, _metadata: &log::Metadata) -> bool {
+		true
+	}
+
+	fn flush(&self) {}
+}
+
+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();
+	log::set_max_level(level);
+	logger
+}
+
 macro_rules! setup_builder {
 	($builder: ident, $config: expr) => {
 		#[cfg(feature = "uniffi")]
@@ -263,11 +307,11 @@ pub(crate) use setup_builder;
 
 pub(crate) fn setup_two_nodes(
 	chain_source: &TestChainSource, allow_0conf: bool, anchor_channels: bool,
-	anchors_trusted_no_reserve: bool,
+	anchors_trusted_no_reserve: bool, log_writer: TestLogWriter,
 ) -> (TestNode, TestNode) {
 	println!("== Node A ==");
 	let config_a = random_config(anchor_channels);
-	let node_a = setup_node(chain_source, config_a, None);
+	let node_a = setup_node(chain_source, config_a, None, log_writer.clone());
 
 	println!("\n== Node B ==");
 	let mut config_b = random_config(anchor_channels);
@@ -282,12 +326,13 @@ pub(crate) fn setup_two_nodes(
 			.trusted_peers_no_reserve
 			.push(node_a.node_id());
 	}
-	let node_b = setup_node(chain_source, config_b, None);
+	let node_b = setup_node(chain_source, config_b, None, log_writer);
 	(node_a, node_b)
 }
 
 pub(crate) fn setup_node(
 	chain_source: &TestChainSource, config: Config, seed_bytes: Option<Vec<u8>>,
+	log_writer: TestLogWriter,
 ) -> TestNode {
 	setup_builder!(builder, config);
 	match chain_source {
@@ -308,6 +353,15 @@ pub(crate) fn setup_node(
 		},
 	}
 
+	match log_writer {
+		TestLogWriter::File(fs_config) => {
+			builder.set_filesystem_logger(fs_config);
+		},
+		TestLogWriter::LogFacade(lf_config) => {
+			builder.set_log_facade_logger(lf_config);
+		},
+	}
+
 	if let Some(seed) = seed_bytes {
 		builder.set_entropy_seed_bytes(seed).unwrap();
 	}