Implement configurable native size/time log rotation & deletion

contrib/ldk-server-config.toml

@@ -15,6 +15,12 @@ dir_path = "/tmp/ldk-server/"                 # Path for LDK and BDK data persis
 [log]
 level = "Debug"                               # Log level (Error, Warn, Info, Debug, Trace)
 #file = "/tmp/ldk-server/ldk-server.log"      # Log file path
+# Enabling `log_to_file` automatically rotate logs at `max_size_mb` or `rotation_interval_hours`. 
+# To disable the internal rotation and keep logging to file, set `max_size_mb` # and `rotation_interval_hours` params to `0`.
+log_to_file = true                            # Enable logging to a file (default: true, also logs to both stdout and stderr)
+#max_size_mb = 50                             # Max size of log file before rotation (default: 50MB)
+#rotation_interval_hours = 24                 # Max age of log file before rotation (default: 24h)
+#max_files = 5                                # Number of rotated log files to keep (default: 5)
 
 [tls]
 #cert_path = "/path/to/tls.crt"               # Path to TLS certificate, by default uses dir_path/tls.crt

docs/configuration.md

@@ -61,8 +61,12 @@ Where persistent data is stored. Defaults to `~/.ldk-server/` on Linux and
 
 ### `[log]`
 
-Log level and file path. The server reopens the log file on `SIGHUP`, which integrates with
-standard `logrotate` setups.
+Controls logging behavior. By default, `log_to_file` is `true` and logs are also written 
+to `stdout`/`stderr`.
+
+If `log_to_file` is enabled, the server performs internal rotation and retention 
+based on `max_size_mb`, `rotation_interval_hours`, and `max_files`. The server will 
+also reopen the log file on `SIGHUP` for compatibility with external tools like `logrotate`.
 
 ### `[tls]`
 

docs/operations.md

@@ -21,13 +21,18 @@ The server handles `SIGTERM` and `CTRL-C` (SIGINT). On receipt, it:
 
 ### Log Rotation
 
-> **Important:** LDK Server does not rotate or truncate its own log file. Without log rotation
-> configured, the log file will grow indefinitely and can eventually fill your disk. A full
-> disk can prevent the node from persisting channel state, risking fund loss.
-
-The server reopens its log file on `SIGHUP`. This integrates with standard `logrotate`. Save
-the following config to `/etc/logrotate.d/ldk-server` (adjust the log path to match your
-setup):
+By default, LDK Server logs to `stdout`/`stderr` and also to file. When running under `systemd` or Docker, 
+this allows the environment (e.g., `journald`) to handle persistence, rotation, and 
+compression automatically.
+
+If you enable `log_to_file` in the configuration, LDK Server will automatically rotate 
+logs when they exceed 50MB or 24 hours (configurable) and keep the last 5 uncompressed 
+log files. But you can disable the internal rotation and keep logging to file by setting
+the `max_size_mb` and `rotation_interval_hours` params to `0`.
+
+If you prefer to use system `logrotate` for file logs, the server still reopens its log 
+file on `SIGHUP`. Save the following config to `/etc/logrotate.d/ldk-server` 
+(adjust the log path to match your setup):
 
 ```
 /var/lib/ldk-server/regtest/ldk-server.log {

ldk-server/src/main.rs

@@ -48,7 +48,7 @@ use crate::io::persist::{
 };
 use crate::service::NodeService;
 use crate::util::config::{load_config, ArgsConfig, ChainSource};
-use crate::util::logger::ServerLogger;
+use crate::util::logger::{LogConfig, ServerLogger};
 use crate::util::metrics::Metrics;
 use crate::util::proto_adapter::{forwarded_payment_to_proto, payment_to_proto};
 use crate::util::systemd;
@@ -110,18 +110,29 @@ fn main() {
 		Network::Regtest => storage_dir.join("regtest"),
 	};
 
-	let log_file_path = config_file.log_file_path.map(PathBuf::from).unwrap_or_else(|| {
-		let mut default_log_path = network_dir.clone();
-		default_log_path.push("ldk-server.log");
-		default_log_path
-	});
+	let log_file_path = if config_file.log_to_file {
+		let path = config_file.log_file_path.map(PathBuf::from).unwrap_or_else(|| {
+			let mut default_log_path = network_dir.clone();
+			default_log_path.push("ldk-server.log");
+			default_log_path
+		});
 
-	if log_file_path == storage_dir || log_file_path == network_dir {
-		eprintln!("Log file path cannot be the same as storage directory path.");
-		std::process::exit(-1);
-	}
+		if path == storage_dir || path == network_dir {
+			eprintln!("Log file path cannot be the same as storage directory path.");
+			std::process::exit(-1);
+		}
+		Some(path)
+	} else {
+		None
+	};
+
+	let log_config = LogConfig {
+		log_max_files: config_file.log_max_files,
+		log_max_size_bytes: config_file.log_max_size_bytes,
+		log_rotation_interval_secs: config_file.log_rotation_interval_secs,
+	};
 
-	let logger = match ServerLogger::init(config_file.log_level, &log_file_path) {
+	let logger = match ServerLogger::init(config_file.log_level, log_file_path, log_config) {
 		Ok(logger) => logger,
 		Err(e) => {
 			eprintln!("Failed to initialize logger: {e}");
@@ -519,6 +530,7 @@ fn main() {
 					break;
 				}
 				_ = sighup_stream.recv() => {
+					info!("Received SIGHUP, reopening log file..");
 					if let Err(e) = logger.reopen() {
 						error!("Failed to reopen log file on SIGHUP: {e}");
 					}
@@ -535,6 +547,7 @@ fn main() {
 	systemd::notify_stopping();
 	node.stop().expect("Shutdown should always succeed.");
 	info!("Shutdown complete..");
+	log::logger().flush();
 }
 
 fn send_event_and_upsert_payment(

ldk-server/src/util/config.rs

@@ -23,6 +23,9 @@ use log::LevelFilter;
 use serde::{Deserialize, Serialize};
 
 const DEFAULT_GRPC_SERVICE_ADDRESS: &str = "127.0.0.1:3536";
+const DEFAULT_LOG_MAX_SIZE_MB: u64 = 50;
+const DEFAULT_LOG_ROTATION_INTERVAL_HOURS: u64 = 24;
+const DEFAULT_LOG_MAX_FILES: usize = 5;
 
 #[cfg(not(test))]
 const DEFAULT_CONFIG_FILE: &str = "config.toml";
@@ -56,6 +59,10 @@ pub struct Config {
 	pub lsps2_service_config: Option<LSPS2ServiceConfig>,
 	pub log_level: LevelFilter,
 	pub log_file_path: Option<String>,
+	pub log_max_size_bytes: usize,
+	pub log_rotation_interval_secs: u64,
+	pub log_max_files: usize,
+	pub log_to_file: bool,
 	pub pathfinding_scores_source_url: Option<String>,
 	pub metrics_enabled: bool,
 	pub poll_metrics_interval: Option<u64>,
@@ -110,6 +117,10 @@ struct ConfigBuilder {
 	lsps2: Option<LiquidityConfig>,
 	log_level: Option<String>,
 	log_file_path: Option<String>,
+	log_max_size_mb: Option<u64>,
+	log_rotation_interval_hours: Option<u64>,
+	log_max_files: Option<usize>,
+	log_to_file: Option<bool>,
 	pathfinding_scores_source_url: Option<String>,
 	metrics_enabled: Option<bool>,
 	poll_metrics_interval: Option<u64>,
@@ -158,6 +169,11 @@ impl ConfigBuilder {
 		if let Some(log) = toml.log {
 			self.log_level = log.level.or(self.log_level.clone());
 			self.log_file_path = log.file.or(self.log_file_path.clone());
+			self.log_max_size_mb = log.max_size_mb.or(self.log_max_size_mb);
+			self.log_rotation_interval_hours =
+				log.rotation_interval_hours.or(self.log_rotation_interval_hours);
+			self.log_max_files = log.max_files.or(self.log_max_files);
+			self.log_to_file = log.log_to_file.or(self.log_to_file);
 		}
 
 		if let Some(liquidity) = toml.liquidity {
@@ -249,6 +265,22 @@ impl ConfigBuilder {
 		if let Some(tor_proxy_address) = &args.tor_proxy_address {
 			self.tor_proxy_address = Some(tor_proxy_address.clone());
 		}
+
+		if let Some(log_max_size_mb) = args.log_max_size_mb {
+			self.log_max_size_mb = Some(log_max_size_mb);
+		}
+
+		if let Some(log_rotation_interval_hours) = args.log_rotation_interval_hours {
+			self.log_rotation_interval_hours = Some(log_rotation_interval_hours);
+		}
+
+		if let Some(log_max_files) = args.log_max_files {
+			self.log_max_files = Some(log_max_files);
+		}
+
+		if let Some(log_file_path) = args.log_to_file {
+			self.log_to_file = Some(log_file_path);
+		}
 	}
 
 	fn build(self) -> io::Result<Config> {
@@ -358,6 +390,14 @@ impl ConfigBuilder {
 			.transpose()?
 			.unwrap_or(LevelFilter::Debug);
 
+		let log_max_size_bytes =
+			self.log_max_size_mb.unwrap_or(DEFAULT_LOG_MAX_SIZE_MB) * 1024 * 1024;
+		let log_rotation_interval_secs =
+			self.log_rotation_interval_hours.unwrap_or(DEFAULT_LOG_ROTATION_INTERVAL_HOURS)
+				* 60 * 60;
+		let log_max_files = self.log_max_files.unwrap_or(DEFAULT_LOG_MAX_FILES);
+		let log_to_file = self.log_to_file.unwrap_or(true);
+
 		let lsps2_client_config = self
 			.lsps2
 			.as_ref()
@@ -428,6 +468,10 @@ impl ConfigBuilder {
 			lsps2_service_config,
 			log_level,
 			log_file_path: self.log_file_path,
+			log_max_size_bytes: log_max_size_bytes as usize,
+			log_rotation_interval_secs,
+			log_max_files,
+			log_to_file,
 			pathfinding_scores_source_url,
 			metrics_enabled,
 			poll_metrics_interval,
@@ -497,6 +541,10 @@ struct EsploraConfig {
 struct LogConfig {
 	level: Option<String>,
 	file: Option<String>,
+	max_size_mb: Option<u64>,
+	rotation_interval_hours: Option<u64>,
+	max_files: Option<usize>,
+	log_to_file: Option<bool>,
 }
 
 #[derive(Deserialize, Serialize)]
@@ -733,6 +781,34 @@ pub struct ArgsConfig {
 	)]
 	node_alias: Option<String>,
 
+	#[arg(
+		long,
+		env = "LDK_SERVER_LOG_MAX_SIZE_MB",
+		help = "The maximum size of the log file in MB before rotation. Defaults to 50MB."
+	)]
+	log_max_size_mb: Option<u64>,
+
+	#[arg(
+		long,
+		env = "LDK_SERVER_LOG_ROTATION_INTERVAL_HOURS",
+		help = "The maximum age of the log file in hours before rotation. Defaults to 24h."
+	)]
+	log_rotation_interval_hours: Option<u64>,
+
+	#[arg(
+		long,
+		env = "LDK_SERVER_LOG_MAX_FILES",
+		help = "The maximum number of rotated log files to keep. Defaults to 5."
+	)]
+	log_max_files: Option<usize>,
+
+	#[arg(
+		long,
+		env = "LDK_SERVER_LOG_TO_FILE",
+		help = "The option to enable logging to a file. Defaults to true. If false, logging to file is disabled."
+	)]
+	log_to_file: Option<bool>,
+
 	#[arg(
 		long,
 		env = "LDK_SERVER_BITCOIND_RPC_ADDRESS",
@@ -896,6 +972,10 @@ mod tests {
 				[log]
 				level = "Trace"
 				file = "/var/log/ldk-server.log"
+				max_size_mb = 50
+				rotation_interval_hours = 24
+				max_files = 5
+				log_to_file = true
 
 				[bitcoind]
 				rpc_address = "127.0.0.1:8332"
@@ -941,6 +1021,10 @@ mod tests {
 			metrics_username: None,
 			metrics_password: None,
 			tor_proxy_address: None,
+			log_to_file: Some(true),
+			log_max_size_mb: Some(50),
+			log_rotation_interval_hours: Some(24),
+			log_max_files: Some(5),
 		}
 	}
 
@@ -962,6 +1046,10 @@ mod tests {
 			metrics_username: None,
 			metrics_password: None,
 			tor_proxy_address: None,
+			log_to_file: Some(true),
+			log_max_size_mb: None,
+			log_rotation_interval_hours: None,
+			log_max_files: None,
 		}
 	}
 
@@ -1029,6 +1117,10 @@ mod tests {
 			}),
 			log_level: LevelFilter::Trace,
 			log_file_path: Some("/var/log/ldk-server.log".to_string()),
+			log_max_size_bytes: 50 * 1024 * 1024,
+			log_rotation_interval_secs: 24 * 60 * 60,
+			log_max_files: 5,
+			log_to_file: true,
 			pathfinding_scores_source_url: None,
 			metrics_enabled: false,
 			poll_metrics_interval: None,
@@ -1344,6 +1436,10 @@ mod tests {
 			metrics_password: None,
 			tor_config: None,
 			hrn_config: HumanReadableNamesConfig::default(),
+			log_max_size_bytes: 50 * 1024 * 1024,
+			log_rotation_interval_secs: 24 * 60 * 60,
+			log_max_files: 5,
+			log_to_file: true,
 		};
 
 		assert_eq!(config.listening_addrs, expected.listening_addrs);
@@ -1357,6 +1453,10 @@ mod tests {
 		assert_eq!(config.pathfinding_scores_source_url, expected.pathfinding_scores_source_url);
 		assert_eq!(config.metrics_enabled, expected.metrics_enabled);
 		assert_eq!(config.tor_config, expected.tor_config);
+		assert_eq!(config.log_max_size_bytes, expected.log_max_size_bytes);
+		assert_eq!(config.log_rotation_interval_secs, expected.log_rotation_interval_secs);
+		assert_eq!(config.log_max_files, expected.log_max_files);
+		assert_eq!(config.log_to_file, expected.log_to_file);
 	}
 
 	#[test]
@@ -1454,6 +1554,10 @@ mod tests {
 				proxy_address: SocketAddress::from_str("127.0.0.1:9050").unwrap(),
 			}),
 			hrn_config: HumanReadableNamesConfig::default(),
+			log_max_size_bytes: 50 * 1024 * 1024,
+			log_rotation_interval_secs: 24 * 60 * 60,
+			log_max_files: 5,
+			log_to_file: false,
 		};
 
 		assert_eq!(config.listening_addrs, expected.listening_addrs);