Make Metrics configurable & address fixups

Author: Anyitechs

e2e-tests/src/lib.rs

@@ -140,6 +140,9 @@ max_client_to_self_delay = 1024
 min_payment_size_msat = 0
 max_payment_size_msat = 1000000000
 client_trusts_lsp = true
+
+[metrics]
+enabled = true
 "#,
 			storage_dir = storage_dir.display(),
 		);

e2e-tests/tests/e2e.rs

@@ -778,3 +778,88 @@ async fn test_hodl_invoice_fail() {
 		events_a.iter().map(|e| &e.event).collect::<Vec<_>>()
 	);
 }
+
+#[tokio::test]
+async fn test_metrics_endpoint() {
+	let bitcoind = TestBitcoind::new();
+
+	// Test with metrics enabled
+	let server_a = LdkServerHandle::start(&bitcoind).await;
+	let server_b = LdkServerHandle::start(&bitcoind).await;
+
+	let client = server_a.client();
+	let metrics_result = client.get_metrics().await;
+
+	assert!(metrics_result.is_ok(), "Expected metrics to succeed when enabled");
+	let metrics = metrics_result.unwrap();
+
+	// Verify initial state
+	assert!(metrics.contains("ldk_server_total_peers_count 0"));
+	assert!(metrics.contains("ldk_server_total_payments_count 0"));
+	assert!(metrics.contains("ldk_server_total_successful_payments_count 0"));
+	assert!(metrics.contains("ldk_server_total_pending_payments_count 0"));
+	assert!(metrics.contains("ldk_server_total_failed_payments_count 0"));
+	assert!(metrics.contains("ldk_server_total_channels_count 0"));
+	assert!(metrics.contains("ldk_server_total_public_channels_count 0"));
+	assert!(metrics.contains("ldk_server_total_private_channels_count 0"));
+	assert!(metrics.contains("ldk_server_total_onchain_balance_sats 0"));
+	assert!(metrics.contains("ldk_server_spendable_onchain_balance_sats 0"));
+	assert!(metrics.contains("ldk_server_total_anchor_channels_reserve_sats 0"));
+	assert!(metrics.contains("ldk_server_total_lightning_balance_sats 0"));
+
+	// Set up channel and make a payment to trigger metric update
+	setup_funded_channel(&bitcoind, &server_a, &server_b, 100_000).await;
+
+	// We need to poll here because the metrics below are poll-based and
+	// updates every 60 seconds.
+	let timeout = Duration::from_secs(65);
+	let start = std::time::Instant::now();
+	loop {
+		let metrics = client.get_metrics().await.unwrap();
+		if metrics.contains("ldk_server_total_peers_count 1")
+			&& metrics.contains("ldk_server_total_channels_count 1")
+			&& metrics.contains("ldk_server_total_public_channels_count 1")
+			&& metrics.contains("ldk_server_total_payments_count 2")
+			&& !metrics.contains("ldk_server_total_lightning_balance_sats 0")
+			&& !metrics.contains("ldk_server_total_onchain_balance_sats 0")
+			&& !metrics.contains("ldk_server_spendable_onchain_balance_sats 0")
+			&& !metrics.contains("ldk_server_total_anchor_channels_reserve_sats 0")
+		{
+			break;
+		}
+
+		if start.elapsed() > timeout {
+			panic!("Timed out waiting for channel/peer metrics to update",);
+		}
+		tokio::time::sleep(Duration::from_secs(1)).await;
+	}
+
+	// Make a payment to trigger payment metric updates.
+	let invoice_resp = server_b
+		.client()
+		.bolt11_receive(Bolt11ReceiveRequest {
+			amount_msat: Some(10_000_000),
+			description: Some(Bolt11InvoiceDescription {
+				kind: Some(bolt11_invoice_description::Kind::Direct("metrics test".to_string())),
+			}),
+			expiry_secs: 3600,
+		})
+		.await
+		.unwrap();
+
+	run_cli(&server_a, &["bolt11-send", &invoice_resp.invoice]);
+
+	// Wait to receive the PaymentSuccessful event and update metrics
+	let timeout = Duration::from_secs(30);
+	let start = std::time::Instant::now();
+	loop {
+		let metrics = client.get_metrics().await.unwrap();
+		if metrics.contains("ldk_server_total_successful_payments_count 1") {
+			break;
+		}
+		if start.elapsed() > timeout {
+			panic!("Timed out waiting for payment metrics to update");
+		}
+		tokio::time::sleep(Duration::from_millis(500)).await;
+	}
+}

ldk-server-client/src/client.rs

@@ -35,10 +35,10 @@ use ldk_server_protos::endpoints::{
 	BOLT11_CLAIM_FOR_HASH_PATH, BOLT11_FAIL_FOR_HASH_PATH, BOLT11_RECEIVE_FOR_HASH_PATH,
 	BOLT11_RECEIVE_PATH, BOLT11_SEND_PATH, BOLT12_RECEIVE_PATH, BOLT12_SEND_PATH,
 	CLOSE_CHANNEL_PATH, CONNECT_PEER_PATH, DISCONNECT_PEER_PATH, EXPORT_PATHFINDING_SCORES_PATH,
-	FORCE_CLOSE_CHANNEL_PATH, GET_BALANCES_PATH, GET_NODE_INFO_PATH, GET_PAYMENT_DETAILS_PATH,
-	GRAPH_GET_CHANNEL_PATH, GRAPH_GET_NODE_PATH, GRAPH_LIST_CHANNELS_PATH, GRAPH_LIST_NODES_PATH,
-	LIST_CHANNELS_PATH, LIST_FORWARDED_PAYMENTS_PATH, LIST_PAYMENTS_PATH,
-	LIST_PEERS_PATH, ONCHAIN_RECEIVE_PATH,
+	FORCE_CLOSE_CHANNEL_PATH, GET_BALANCES_PATH, GET_METRICS_PATH, GET_NODE_INFO_PATH,
+	GET_PAYMENT_DETAILS_PATH, GRAPH_GET_CHANNEL_PATH, GRAPH_GET_NODE_PATH,
+	GRAPH_LIST_CHANNELS_PATH, GRAPH_LIST_NODES_PATH, LIST_CHANNELS_PATH,
+	LIST_FORWARDED_PAYMENTS_PATH, LIST_PAYMENTS_PATH, LIST_PEERS_PATH, ONCHAIN_RECEIVE_PATH,
 	ONCHAIN_SEND_PATH, OPEN_CHANNEL_PATH, SIGN_MESSAGE_PATH, SPLICE_IN_PATH, SPLICE_OUT_PATH,
 	SPONTANEOUS_SEND_PATH, UPDATE_CHANNEL_CONFIG_PATH, VERIFY_SIGNATURE_PATH,
 };
@@ -427,9 +427,8 @@ impl LdkServerClient {
 			RequestType::Post => self.client.post(url),
 		};
 
-		let body_for_auth = body.as_deref().unwrap_or(&[]);
-
 		let builder = if authenticated {
+			let body_for_auth = body.as_deref().unwrap_or(&[]);
 			let auth_header = self.compute_auth_header(body_for_auth);
 			builder.header("X-Auth", auth_header)
 		} else {

ldk-server/ldk-server-config.toml

@@ -79,3 +79,7 @@ client_trusts_lsp = false
 ## A token we may require to be sent by the clients.
 ## If set, only requests matching this token will be accepted. (uncomment and set if required)
 # require_token = ""
+
+# Metrics settings
+[metrics]
+enabled = false

ldk-server/src/main.rs

@@ -267,18 +267,25 @@ fn main() {
 		};
 		let event_node = Arc::clone(&node);
 
-		let metrics_node = Arc::clone(&node);
-		let mut interval = tokio::time::interval(BUILD_METRICS_INTERVAL);
-		let metrics = Arc::new(Metrics::new());
-		let metrics_bg = Arc::clone(&metrics);
-		let event_metrics = Arc::clone(&metrics);
-
-		runtime.spawn(async move {
-			loop {
-				interval.tick().await;
-				metrics_bg.update_all_pollable_metrics(&metrics_node);
-			}
-		});
+		let metrics: Option<Arc<Metrics>> = if config_file.metrics_enabled {
+			let metrics_node = Arc::clone(&node);
+			let mut interval = tokio::time::interval(BUILD_METRICS_INTERVAL);
+			let metrics = Arc::new(Metrics::new());
+			let metrics_bg = Arc::clone(&metrics);
+
+			// Initialize metrics that are event-driven to ensure they start with correct values from persistence
+			metrics.initialize_payment_metrics(&metrics_node);
+
+			runtime.spawn(async move {
+				loop {
+					interval.tick().await;
+					metrics_bg.update_all_pollable_metrics(&metrics_node);
+				}
+			});
+			Some(metrics)
+		} else {
+			None
+		};
 
 		let rest_svc_listener = TcpListener::bind(config_file.rest_service_addr)
 			.await
@@ -347,7 +354,9 @@ fn main() {
 								Arc::clone(&event_publisher),
 								Arc::clone(&paginated_store)).await;
 
-							event_metrics.update_total_successful_payments_count(&event_node);
+							if let Some(metrics) = &metrics {
+								metrics.update_payments_count(true);
+							}
 						},
 						Event::PaymentFailed {payment_id, ..} => {
 							let payment_id = payment_id.expect("PaymentId expected for ldk-server >=0.1");
@@ -360,7 +369,9 @@ fn main() {
 								Arc::clone(&event_publisher),
 								Arc::clone(&paginated_store)).await;
 
-							event_metrics.update_total_failed_payments_count(&event_node);
+							if let Some(metrics) = &metrics {
+								metrics.update_payments_count(false);
+							}
 						},
 						Event::PaymentClaimable {payment_id, ..} => {
 							publish_event_and_upsert_payment(&payment_id,
@@ -446,7 +457,7 @@ fn main() {
 				res = rest_svc_listener.accept() => {
 					match res {
 						Ok((stream, _)) => {
-							let node_service = NodeService::new(Arc::clone(&node), Arc::clone(&paginated_store), api_key.clone(), Arc::clone(&metrics));
+							let node_service = NodeService::new(Arc::clone(&node), Arc::clone(&paginated_store), api_key.clone(), metrics.clone());
 							let acceptor = tls_acceptor.clone();
 							runtime.spawn(async move {
 								match acceptor.accept(stream).await {

ldk-server/src/service.rs

@@ -22,10 +22,10 @@ use ldk_server_protos::endpoints::{
 	BOLT11_CLAIM_FOR_HASH_PATH, BOLT11_FAIL_FOR_HASH_PATH, BOLT11_RECEIVE_FOR_HASH_PATH,
 	BOLT11_RECEIVE_PATH, BOLT11_SEND_PATH, BOLT12_RECEIVE_PATH, BOLT12_SEND_PATH,
 	CLOSE_CHANNEL_PATH, CONNECT_PEER_PATH, DISCONNECT_PEER_PATH, EXPORT_PATHFINDING_SCORES_PATH,
-	FORCE_CLOSE_CHANNEL_PATH, GET_BALANCES_PATH, GET_NODE_INFO_PATH, GET_PAYMENT_DETAILS_PATH,
-	GRAPH_GET_CHANNEL_PATH, GRAPH_GET_NODE_PATH, GRAPH_LIST_CHANNELS_PATH, GRAPH_LIST_NODES_PATH,
-	LIST_CHANNELS_PATH, LIST_FORWARDED_PAYMENTS_PATH, LIST_PAYMENTS_PATH,
-	LIST_PEERS_PATH, ONCHAIN_RECEIVE_PATH,
+	FORCE_CLOSE_CHANNEL_PATH, GET_BALANCES_PATH, GET_METRICS_PATH, GET_NODE_INFO_PATH,
+	GET_PAYMENT_DETAILS_PATH, GRAPH_GET_CHANNEL_PATH, GRAPH_GET_NODE_PATH,
+	GRAPH_LIST_CHANNELS_PATH, GRAPH_LIST_NODES_PATH, LIST_CHANNELS_PATH,
+	LIST_FORWARDED_PAYMENTS_PATH, LIST_PAYMENTS_PATH, LIST_PEERS_PATH, ONCHAIN_RECEIVE_PATH,
 	ONCHAIN_SEND_PATH, OPEN_CHANNEL_PATH, SIGN_MESSAGE_PATH, SPLICE_IN_PATH, SPLICE_OUT_PATH,
 	SPONTANEOUS_SEND_PATH, UPDATE_CHANNEL_CONFIG_PATH, VERIFY_SIGNATURE_PATH,
 };
@@ -76,13 +76,13 @@ pub struct NodeService {
 	node: Arc<Node>,
 	paginated_kv_store: Arc<dyn PaginatedKVStore>,
 	api_key: String,
-	metrics: Arc<Metrics>,
+	metrics: Option<Arc<Metrics>>,
 }
 
 impl NodeService {
 	pub(crate) fn new(
 		node: Arc<Node>, paginated_kv_store: Arc<dyn PaginatedKVStore>, api_key: String,
-		metrics: Arc<Metrics>,
+		metrics: Option<Arc<Metrics>>,
 	) -> Self {
 		Self { node, paginated_kv_store, api_key, metrics }
 	}
@@ -169,14 +169,26 @@ impl Service<Request<Incoming>> for NodeService {
 
 	fn call(&self, req: Request<Incoming>) -> Self::Future {
 		// Handle metrics endpoint separately to bypass auth and return plain text
-		if req.uri().path().len() > 1 && &req.uri().path()[1..] == GET_METRICS_PATH {
-			let metrics = Arc::clone(&self.metrics);
-			return Box::pin(async move {
-				Ok(Response::builder()
-					.header("Content-Type", "text/plain")
-					.body(Full::new(Bytes::from(metrics.gather_metrics())))
-					.unwrap())
-			});
+		if req.method() == hyper::Method::GET
+			&& req.uri().path().len() > 1
+			&& &req.uri().path()[1..] == GET_METRICS_PATH
+		{
+			if let Some(metrics) = &self.metrics {
+				let metrics = Arc::clone(metrics);
+				return Box::pin(async move {
+					Ok(Response::builder()
+						.header("Content-Type", "text/plain")
+						.body(Full::new(Bytes::from(metrics.gather_metrics())))
+						.unwrap())
+				});
+			} else {
+				return Box::pin(async move {
+					Ok(Response::builder()
+						.status(StatusCode::NOT_FOUND)
+						.body(Full::new(Bytes::from("Not Found")))
+						.unwrap())
+				});
+			}
 		}
 
 		// Extract auth params from headers (validation happens after body is read)