From 8e5a930eb3bbe5e6ad788ada4a4d87214ff3e2d2 Mon Sep 17 00:00:00 2001 From: Roland Sherwin Date: Tue, 18 Feb 2025 20:16:26 +0530 Subject: [PATCH 1/6] fix(relay): remove relay clients if we have no more connections --- ant-networking/src/event/swarm.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/ant-networking/src/event/swarm.rs b/ant-networking/src/event/swarm.rs index 599a97ab91..d029997056 100644 --- a/ant-networking/src/event/swarm.rs +++ b/ant-networking/src/event/swarm.rs @@ -107,9 +107,11 @@ impl SwarmDriver { renewed: _, } => { self.connected_relay_clients.insert(src_peer_id); + info!("Relay reservation accepted from {src_peer_id:?}. Relay client count: {}", self.connected_relay_clients.len()); } libp2p::relay::Event::ReservationTimedOut { src_peer_id } => { self.connected_relay_clients.remove(&src_peer_id); + info!("Relay reservation timed out from {src_peer_id:?}. Relay client count: {}", self.connected_relay_clients.len()); } _ => {} } @@ -264,6 +266,14 @@ impl SwarmDriver { event_string = "ConnectionClosed"; debug!(%peer_id, ?connection_id, ?cause, num_established, "ConnectionClosed: {}", endpoint_str(&endpoint)); let _ = self.live_connected_peers.remove(&connection_id); + + if num_established == 0 && self.connected_relay_clients.remove(&peer_id) { + info!( + "Relay client has been disconnected: {peer_id:?}. Relay client count: {}", + self.connected_relay_clients.len() + ); + } + self.record_connection_metrics(); } SwarmEvent::OutgoingConnectionError { From e00749d649d21eaa1575fe8080014705d6a96a13 Mon Sep 17 00:00:00 2001 From: Roland Sherwin Date: Thu, 20 Feb 2025 02:12:16 +0530 Subject: [PATCH 2/6] fix(metrics): caclulate peers in rt directly from kbuckets --- ant-networking/src/cmd.rs | 13 +--- ant-networking/src/driver.rs | 20 +++--- ant-networking/src/event/mod.rs | 124 +++++++++++++++++--------------- 3 files changed, 76 insertions(+), 81 deletions(-) diff --git a/ant-networking/src/cmd.rs b/ant-networking/src/cmd.rs index bc42fa4fbf..9d50657ea8 100644 --- a/ant-networking/src/cmd.rs +++ b/ant-networking/src/cmd.rs @@ -626,15 +626,8 @@ impl SwarmDriver { sender, } => { cmd_string = "GetLocalQuotingMetrics"; - let ( - _index, - _total_peers, - peers_in_non_full_buckets, - num_of_full_buckets, - _kbucket_table_stats, - ) = self.kbuckets_status(); - let estimated_network_size = - Self::estimate_network_size(peers_in_non_full_buckets, num_of_full_buckets); + let kbucket_status = self.get_kbuckets_status(); + self.update_on_kbucket_status(&kbucket_status); let (quoting_metrics, is_already_stored) = match self .swarm .behaviour_mut() @@ -644,7 +637,7 @@ impl SwarmDriver { &key, data_type, data_size, - Some(estimated_network_size as u64), + Some(kbucket_status.estimated_network_size as u64), ) { Ok(res) => res, Err(err) => { diff --git a/ant-networking/src/driver.rs b/ant-networking/src/driver.rs index db91c7e98a..45874e0fae 100644 --- a/ant-networking/src/driver.rs +++ b/ant-networking/src/driver.rs @@ -841,24 +841,20 @@ impl SwarmDriver { } _ = set_farthest_record_interval.tick() => { if !self.is_client { - let ( - _index, - _total_peers, - peers_in_non_full_buckets, - num_of_full_buckets, - _kbucket_table_stats, - ) = self.kbuckets_status(); - let estimated_network_size = - Self::estimate_network_size(peers_in_non_full_buckets, num_of_full_buckets); - if estimated_network_size <= CLOSE_GROUP_SIZE { - info!("Not enough estimated network size {estimated_network_size}, with {peers_in_non_full_buckets} peers_in_non_full_buckets and {num_of_full_buckets}num_of_full_buckets."); + let kbucket_status = self.get_kbuckets_status(); + self.update_on_kbucket_status(&kbucket_status); + if kbucket_status.estimated_network_size <= CLOSE_GROUP_SIZE { + info!("Not enough estimated network size {}, with {} peers_in_non_full_buckets and {} num_of_full_buckets.", + kbucket_status.estimated_network_size, + kbucket_status.peers_in_non_full_buckets, + kbucket_status.num_of_full_buckets); continue; } // The entire Distance space is U256 // (U256::MAX is 115792089237316195423570985008687907853269984665640564039457584007913129639935) // The network density (average distance among nodes) can be estimated as: // network_density = entire_U256_space / estimated_network_size - let density = U256::MAX / U256::from(estimated_network_size); + let density = U256::MAX / U256::from(kbucket_status.estimated_network_size); let density_distance = density * U256::from(CLOSE_GROUP_SIZE); // Use distance to close peer to avoid the situation that diff --git a/ant-networking/src/event/mod.rs b/ant-networking/src/event/mod.rs index 2ad32c079f..54f614b179 100644 --- a/ant-networking/src/event/mod.rs +++ b/ant-networking/src/event/mod.rs @@ -37,8 +37,29 @@ use std::{ }; use tokio::sync::oneshot; -// (total_buckets, total_peers, peers_in_non_full_buckets, num_of_full_buckets, kbucket_table_stats) -type KBucketStatus = (usize, usize, usize, usize, Vec<(usize, usize, u32)>); +#[derive(Debug, Clone)] +pub(crate) struct KBucketStatus { + pub(crate) total_buckets: usize, + pub(crate) total_peers: usize, + pub(crate) peers_in_non_full_buckets: usize, + pub(crate) num_of_full_buckets: usize, + pub(crate) kbucket_table_stats: Vec<(usize, usize, u32)>, + pub(crate) estimated_network_size: usize, +} + +impl KBucketStatus { + pub(crate) fn log(&self) { + info!( + "kBucketTable has {:?} kbuckets {:?} peers, {:?}, estimated network size: {:?}", + self.total_buckets, + self.total_peers, + self.kbucket_table_stats, + self.estimated_network_size + ); + #[cfg(feature = "loud")] + println!("Estimated network size: {:?}", self.estimated_network_size); + } +} /// NodeEvent enum #[derive(CustomDebug)] @@ -239,12 +260,21 @@ impl SwarmDriver { /// Update state on addition of a peer to the routing table. pub(crate) fn update_on_peer_addition(&mut self, added_peer: PeerId, addresses: Addresses) { - self.peers_in_rt = self.peers_in_rt.saturating_add(1); - let n_peers = self.peers_in_rt; - info!("New peer added to routing table: {added_peer:?}, now we have #{n_peers} connected peers"); + let kbucket_status = self.get_kbuckets_status(); + self.update_on_kbucket_status(&kbucket_status); + + let distance = NetworkAddress::from_peer(self.self_peer_id) + .distance(&NetworkAddress::from_peer(added_peer)); + info!("New peer added to routing table: {added_peer:?}. We now have #{} connected peers. It has a {:?} distance to us.", + self.peers_in_rt, distance.ilog2()); #[cfg(feature = "loud")] - println!("New peer added to routing table: {added_peer:?}, now we have #{n_peers} connected peers"); + println!( + "New peer added to routing table: {added_peer:?}, now we have #{} connected peers", + self.peers_in_rt + ); + + kbucket_status.log(); if let Some(bootstrap_cache) = &mut self.bootstrap_cache { for addr in addresses.iter() { @@ -252,52 +282,42 @@ impl SwarmDriver { } } - self.log_kbuckets(&added_peer); self.send_event(NetworkEvent::PeerAdded(added_peer, self.peers_in_rt)); #[cfg(feature = "open-metrics")] if self.metrics_recorder.is_some() { self.check_for_change_in_our_close_group(); } - - #[cfg(feature = "open-metrics")] - if let Some(metrics_recorder) = &self.metrics_recorder { - metrics_recorder - .peers_in_routing_table - .set(self.peers_in_rt as i64); - } } /// Update state on removal of a peer from the routing table. pub(crate) fn update_on_peer_removal(&mut self, removed_peer: PeerId) { - self.peers_in_rt = self.peers_in_rt.saturating_sub(1); + let kbucket_status = self.get_kbuckets_status(); + self.update_on_kbucket_status(&kbucket_status); // ensure we disconnect bad peer // err result just means no connections were open let _result = self.swarm.disconnect_peer_id(removed_peer); + let distance = NetworkAddress::from_peer(self.self_peer_id) + .distance(&NetworkAddress::from_peer(removed_peer)); info!( - "Peer removed from routing table: {removed_peer:?}, now we have #{} connected peers", - self.peers_in_rt + "Peer removed from routing table: {removed_peer:?}. We now have #{} connected peers. It has a {:?} distance to us.", + self.peers_in_rt, distance.ilog2() ); - self.log_kbuckets(&removed_peer); + self.send_event(NetworkEvent::PeerRemoved(removed_peer, self.peers_in_rt)); + kbucket_status.log(); + #[cfg(feature = "open-metrics")] if self.metrics_recorder.is_some() { self.check_for_change_in_our_close_group(); } - - #[cfg(feature = "open-metrics")] - if let Some(metrics_recorder) = &self.metrics_recorder { - metrics_recorder - .peers_in_routing_table - .set(self.peers_in_rt as i64); - } } - /// Collect kbuckets status - pub(crate) fn kbuckets_status(&mut self) -> KBucketStatus { + /// Get the status of the kbucket table. + pub(crate) fn get_kbuckets_status(&mut self) -> KBucketStatus { let mut kbucket_table_stats = vec![]; let mut index = 0; let mut total_peers = 0; @@ -324,51 +344,37 @@ impl SwarmDriver { } index += 1; } - ( - index, - total_peers, - peers_in_non_full_buckets, - num_of_full_buckets, - kbucket_table_stats, - ) - } - /// Logs the kbuckets also records the bucket info. - pub(crate) fn log_kbuckets(&mut self, peer: &PeerId) { - let distance = NetworkAddress::from_peer(self.self_peer_id) - .distance(&NetworkAddress::from_peer(*peer)); - info!("Peer {peer:?} has a {:?} distance to us", distance.ilog2()); + let estimated_network_size = + Self::estimate_network_size(peers_in_non_full_buckets, num_of_full_buckets); - let ( - index, + KBucketStatus { + total_buckets: index, total_peers, peers_in_non_full_buckets, num_of_full_buckets, kbucket_table_stats, - ) = self.kbuckets_status(); + estimated_network_size, + } + } - let estimated_network_size = - Self::estimate_network_size(peers_in_non_full_buckets, num_of_full_buckets); + /// Update SwarmDriver field & also record metrics based on the newly calculated kbucket status. + pub(crate) fn update_on_kbucket_status(&mut self, status: &KBucketStatus) { + self.peers_in_rt = status.total_peers; #[cfg(feature = "open-metrics")] if let Some(metrics_recorder) = &self.metrics_recorder { + metrics_recorder + .peers_in_routing_table + .set(status.total_peers as i64); + + let estimated_network_size = Self::estimate_network_size( + status.peers_in_non_full_buckets, + status.num_of_full_buckets, + ); let _ = metrics_recorder .estimated_network_size .set(estimated_network_size as i64); } - - // Just to warn if our tracking goes out of sync with libp2p. Can happen if someone forgets to call - // update_on_peer_addition or update_on_peer_removal when adding or removing a peer. - // Only log every 10th peer to avoid spamming the logs. - if total_peers % 10 == 0 && total_peers != self.peers_in_rt { - warn!( - "Total peers in routing table: {}, but kbucket table has {total_peers} peers", - self.peers_in_rt - ); - } - - info!("kBucketTable has {index:?} kbuckets {total_peers:?} peers, {kbucket_table_stats:?}, estimated network size: {estimated_network_size:?}"); - #[cfg(feature = "loud")] - println!("Estimated network size: {estimated_network_size:?}"); } /// Estimate the number of nodes in the network From 342a50cfbee86a43d020f688822058ce2b6682b3 Mon Sep 17 00:00:00 2001 From: Roland Sherwin Date: Wed, 19 Feb 2025 19:06:25 +0530 Subject: [PATCH 3/6] feat(metrics): add more metrics related to relays --- ant-networking/src/event/identify.rs | 2 +- ant-networking/src/event/mod.rs | 34 ++++++++++++++++++++++++-- ant-networking/src/metrics/mod.rs | 36 ++++++++++++++++++++++++++-- ant-networking/src/relay_manager.rs | 6 ++--- 4 files changed, 69 insertions(+), 9 deletions(-) diff --git a/ant-networking/src/event/identify.rs b/ant-networking/src/event/identify.rs index c06eac14e5..6b9ee45cdd 100644 --- a/ant-networking/src/event/identify.rs +++ b/ant-networking/src/event/identify.rs @@ -88,7 +88,7 @@ impl SwarmDriver { .collect(), }; - let is_relayed_peer = is_a_relayed_peer(&addrs); + let is_relayed_peer = is_a_relayed_peer(addrs.iter()); let is_bootstrap_peer = self .bootstrap_peers diff --git a/ant-networking/src/event/mod.rs b/ant-networking/src/event/mod.rs index 54f614b179..a8f08796a7 100644 --- a/ant-networking/src/event/mod.rs +++ b/ant-networking/src/event/mod.rs @@ -11,7 +11,7 @@ mod kad; mod request_response; mod swarm; -use crate::{driver::SwarmDriver, error::Result}; +use crate::{driver::SwarmDriver, error::Result, relay_manager::is_a_relayed_peer}; use core::fmt; use custom_debug::Debug as CustomDebug; use libp2p::{ @@ -41,7 +41,9 @@ use tokio::sync::oneshot; pub(crate) struct KBucketStatus { pub(crate) total_buckets: usize, pub(crate) total_peers: usize, + pub(crate) total_relay_peers: usize, pub(crate) peers_in_non_full_buckets: usize, + pub(crate) relay_peers_in_non_full_buckets: usize, pub(crate) num_of_full_buckets: usize, pub(crate) kbucket_table_stats: Vec<(usize, usize, u32)>, pub(crate) estimated_network_size: usize, @@ -284,7 +286,6 @@ impl SwarmDriver { self.send_event(NetworkEvent::PeerAdded(added_peer, self.peers_in_rt)); - #[cfg(feature = "open-metrics")] if self.metrics_recorder.is_some() { self.check_for_change_in_our_close_group(); } @@ -321,14 +322,25 @@ impl SwarmDriver { let mut kbucket_table_stats = vec![]; let mut index = 0; let mut total_peers = 0; + let mut total_relay_peers = 0; let mut peers_in_non_full_buckets = 0; + let mut relay_peers_in_non_full_buckets = 0; let mut num_of_full_buckets = 0; for kbucket in self.swarm.behaviour_mut().kademlia.kbuckets() { let range = kbucket.range(); let num_entires = kbucket.num_entries(); + kbucket.iter().for_each(|entry| { + if is_a_relayed_peer(entry.node.value.iter()) { + total_relay_peers += 1; + if num_entires < K_VALUE.get() { + relay_peers_in_non_full_buckets += 1; + } + } + }); + if num_entires >= K_VALUE.get() { num_of_full_buckets += 1; } else { @@ -351,7 +363,9 @@ impl SwarmDriver { KBucketStatus { total_buckets: index, total_peers, + total_relay_peers, peers_in_non_full_buckets, + relay_peers_in_non_full_buckets, num_of_full_buckets, kbucket_table_stats, estimated_network_size, @@ -367,6 +381,18 @@ impl SwarmDriver { .peers_in_routing_table .set(status.total_peers as i64); + let _ = metrics_recorder + .relay_peers_in_routing_table + .set(status.total_relay_peers as i64); + + let _ = metrics_recorder + .peers_in_non_full_buckets + .set(status.peers_in_non_full_buckets as i64); + + let _ = metrics_recorder + .relay_peers_in_non_full_buckets + .set(status.relay_peers_in_non_full_buckets as i64); + let estimated_network_size = Self::estimate_network_size( status.peers_in_non_full_buckets, status.num_of_full_buckets, @@ -374,6 +400,10 @@ impl SwarmDriver { let _ = metrics_recorder .estimated_network_size .set(estimated_network_size as i64); + + let _ = metrics_recorder + .percentage_of_relay_peers + .set((status.total_relay_peers as f64 / status.total_peers as f64) * 100.0); } } diff --git a/ant-networking/src/metrics/mod.rs b/ant-networking/src/metrics/mod.rs index c78508ecb1..92e032c599 100644 --- a/ant-networking/src/metrics/mod.rs +++ b/ant-networking/src/metrics/mod.rs @@ -12,8 +12,6 @@ mod relay_client; pub mod service; mod upnp; -use std::sync::atomic::AtomicU64; - use crate::MetricsRegistries; use crate::{log_markers::Marker, time::sleep}; use bad_node::{BadNodeMetrics, BadNodeMetricsMsg, TimeFrame}; @@ -25,6 +23,7 @@ use prometheus_client::{ metrics::family::Family, metrics::{counter::Counter, gauge::Gauge}, }; +use std::sync::atomic::AtomicU64; use sysinfo::{Pid, ProcessRefreshKind, System}; use tokio::time::Duration; @@ -43,8 +42,12 @@ pub(crate) struct NetworkMetricsRecorder { // metrics from ant-networking pub(crate) connected_peers: Gauge, pub(crate) estimated_network_size: Gauge, + pub(crate) percentage_of_relay_peers: Gauge, pub(crate) open_connections: Gauge, pub(crate) peers_in_routing_table: Gauge, + pub(crate) relay_peers_in_routing_table: Gauge, + pub(crate) peers_in_non_full_buckets: Gauge, + pub(crate) relay_peers_in_non_full_buckets: Gauge, pub(crate) records_stored: Gauge, pub(crate) relay_reservation_health: Gauge, @@ -107,6 +110,12 @@ impl NetworkMetricsRecorder { "The estimated number of nodes in the network calculated by the peers in our RT", estimated_network_size.clone(), ); + let percentage_of_relay_peers = Gauge::::default(); + sub_registry.register( + "percentage_of_relay_peers", + "The percentage of relay peers in our routing table", + percentage_of_relay_peers.clone(), + ); let open_connections = Gauge::default(); sub_registry.register( "open_connections", @@ -119,6 +128,25 @@ impl NetworkMetricsRecorder { "The total number of peers in our routing table", peers_in_routing_table.clone(), ); + let relay_peers_in_routing_table = Gauge::default(); + sub_registry.register( + "relay_peers_in_routing_table", + "The total number of relay peers in our routing table", + relay_peers_in_routing_table.clone(), + ); + + let peers_in_non_full_buckets = Gauge::default(); + sub_registry.register( + "peers_in_non_full_buckets", + "The number of peers in our routing table that are not in full buckets", + peers_in_non_full_buckets.clone(), + ); + let relay_peers_in_non_full_buckets = Gauge::default(); + sub_registry.register( + "relay_peers_in_non_full_buckets", + "The number of relay peers in our routing table that are not in full buckets", + relay_peers_in_non_full_buckets.clone(), + ); let shunned_count = Counter::default(); sub_registry.register( @@ -226,10 +254,14 @@ impl NetworkMetricsRecorder { records_stored, estimated_network_size, + percentage_of_relay_peers, connected_peers, open_connections, relay_reservation_health, peers_in_routing_table, + relay_peers_in_routing_table, + peers_in_non_full_buckets, + relay_peers_in_non_full_buckets, relevant_records, max_records, received_payment_count, diff --git a/ant-networking/src/relay_manager.rs b/ant-networking/src/relay_manager.rs index 896467a4f3..649c80e313 100644 --- a/ant-networking/src/relay_manager.rs +++ b/ant-networking/src/relay_manager.rs @@ -41,10 +41,8 @@ const RESERVATION_SCORE_ROLLING_WINDOW: usize = 100; #[cfg(feature = "open-metrics")] type ConnectionsFromPeer = Vec<(PeerId, ConnectionId, SystemTime, Option)>; -pub(crate) fn is_a_relayed_peer(addrs: &HashSet) -> bool { - addrs - .iter() - .any(|multiaddr| multiaddr.iter().any(|p| matches!(p, Protocol::P2pCircuit))) +pub(crate) fn is_a_relayed_peer<'a>(mut addrs: impl Iterator) -> bool { + addrs.any(|multiaddr| multiaddr.iter().any(|p| matches!(p, Protocol::P2pCircuit))) } /// Manage the relay servers that a private node is connected to. From c28ceaa3e0f1a087fc3ab2d211605a9e60619ad9 Mon Sep 17 00:00:00 2001 From: Roland Sherwin Date: Thu, 20 Feb 2025 21:16:24 +0530 Subject: [PATCH 4/6] feat(metrics): add metrics to denote the number of relay clients connected to us --- ant-networking/src/event/mod.rs | 4 +++- ant-networking/src/event/swarm.rs | 24 +++++++++++++++++++++--- ant-networking/src/metrics/mod.rs | 8 ++++++++ 3 files changed, 32 insertions(+), 4 deletions(-) diff --git a/ant-networking/src/event/mod.rs b/ant-networking/src/event/mod.rs index a8f08796a7..5153648ee7 100644 --- a/ant-networking/src/event/mod.rs +++ b/ant-networking/src/event/mod.rs @@ -52,9 +52,10 @@ pub(crate) struct KBucketStatus { impl KBucketStatus { pub(crate) fn log(&self) { info!( - "kBucketTable has {:?} kbuckets {:?} peers, {:?}, estimated network size: {:?}", + "kBucketTable has {:?} kbuckets {:?} peers ({} relay peers), {:?}, estimated network size: {:?}", self.total_buckets, self.total_peers, + self.total_relay_peers, self.kbucket_table_stats, self.estimated_network_size ); @@ -286,6 +287,7 @@ impl SwarmDriver { self.send_event(NetworkEvent::PeerAdded(added_peer, self.peers_in_rt)); + #[cfg(feature = "open-metrics")] if self.metrics_recorder.is_some() { self.check_for_change_in_our_close_group(); } diff --git a/ant-networking/src/event/swarm.rs b/ant-networking/src/event/swarm.rs index d029997056..1dccc17fcf 100644 --- a/ant-networking/src/event/swarm.rs +++ b/ant-networking/src/event/swarm.rs @@ -108,10 +108,24 @@ impl SwarmDriver { } => { self.connected_relay_clients.insert(src_peer_id); info!("Relay reservation accepted from {src_peer_id:?}. Relay client count: {}", self.connected_relay_clients.len()); + + #[cfg(feature = "open-metrics")] + if let Some(metrics_recorder) = &self.metrics_recorder { + metrics_recorder + .connected_relay_clients + .set(self.connected_relay_clients.len() as i64); + } } libp2p::relay::Event::ReservationTimedOut { src_peer_id } => { self.connected_relay_clients.remove(&src_peer_id); info!("Relay reservation timed out from {src_peer_id:?}. Relay client count: {}", self.connected_relay_clients.len()); + + #[cfg(feature = "open-metrics")] + if let Some(metrics_recorder) = &self.metrics_recorder { + metrics_recorder + .connected_relay_clients + .set(self.connected_relay_clients.len() as i64); + } } _ => {} } @@ -604,13 +618,17 @@ impl SwarmDriver { /// Record the metrics on update of connection state. fn record_connection_metrics(&self) { #[cfg(feature = "open-metrics")] - if let Some(metrics) = &self.metrics_recorder { - metrics + if let Some(metrics_recorder) = &self.metrics_recorder { + metrics_recorder .open_connections .set(self.live_connected_peers.len() as i64); - metrics + metrics_recorder .connected_peers .set(self.swarm.connected_peers().count() as i64); + + metrics_recorder + .connected_relay_clients + .set(self.connected_relay_clients.len() as i64); } } diff --git a/ant-networking/src/metrics/mod.rs b/ant-networking/src/metrics/mod.rs index 92e032c599..31335ad2c0 100644 --- a/ant-networking/src/metrics/mod.rs +++ b/ant-networking/src/metrics/mod.rs @@ -41,6 +41,7 @@ pub(crate) struct NetworkMetricsRecorder { // metrics from ant-networking pub(crate) connected_peers: Gauge, + pub(crate) connected_relay_clients: Gauge, pub(crate) estimated_network_size: Gauge, pub(crate) percentage_of_relay_peers: Gauge, pub(crate) open_connections: Gauge, @@ -103,6 +104,12 @@ impl NetworkMetricsRecorder { "The number of peers that we are currently connected to", connected_peers.clone(), ); + let connected_relay_clients = Gauge::default(); + sub_registry.register( + "connected_relay_clients", + "The number of relay clients that are currently connected to us", + connected_relay_clients.clone(), + ); let estimated_network_size = Gauge::default(); sub_registry.register( @@ -256,6 +263,7 @@ impl NetworkMetricsRecorder { estimated_network_size, percentage_of_relay_peers, connected_peers, + connected_relay_clients, open_connections, relay_reservation_health, peers_in_routing_table, From 06e59ec02ae989995265561d65fdfa92ae2e267f Mon Sep 17 00:00:00 2001 From: qima Date: Fri, 21 Feb 2025 20:40:29 +0800 Subject: [PATCH 5/6] fix(node): correct relay_nodes percentage calculation and remove un-needed metrics --- ant-networking/src/event/mod.rs | 16 +++++----------- ant-networking/src/metrics/mod.rs | 17 ----------------- 2 files changed, 5 insertions(+), 28 deletions(-) diff --git a/ant-networking/src/event/mod.rs b/ant-networking/src/event/mod.rs index 5153648ee7..4c98614691 100644 --- a/ant-networking/src/event/mod.rs +++ b/ant-networking/src/event/mod.rs @@ -387,14 +387,6 @@ impl SwarmDriver { .relay_peers_in_routing_table .set(status.total_relay_peers as i64); - let _ = metrics_recorder - .peers_in_non_full_buckets - .set(status.peers_in_non_full_buckets as i64); - - let _ = metrics_recorder - .relay_peers_in_non_full_buckets - .set(status.relay_peers_in_non_full_buckets as i64); - let estimated_network_size = Self::estimate_network_size( status.peers_in_non_full_buckets, status.num_of_full_buckets, @@ -403,9 +395,11 @@ impl SwarmDriver { .estimated_network_size .set(estimated_network_size as i64); - let _ = metrics_recorder - .percentage_of_relay_peers - .set((status.total_relay_peers as f64 / status.total_peers as f64) * 100.0); + let _ = metrics_recorder.percentage_of_relay_peers.set( + (status.relay_peers_in_non_full_buckets as f64 + / status.peers_in_non_full_buckets as f64) + * 100.0, + ); } } diff --git a/ant-networking/src/metrics/mod.rs b/ant-networking/src/metrics/mod.rs index 31335ad2c0..bc78c099de 100644 --- a/ant-networking/src/metrics/mod.rs +++ b/ant-networking/src/metrics/mod.rs @@ -47,8 +47,6 @@ pub(crate) struct NetworkMetricsRecorder { pub(crate) open_connections: Gauge, pub(crate) peers_in_routing_table: Gauge, pub(crate) relay_peers_in_routing_table: Gauge, - pub(crate) peers_in_non_full_buckets: Gauge, - pub(crate) relay_peers_in_non_full_buckets: Gauge, pub(crate) records_stored: Gauge, pub(crate) relay_reservation_health: Gauge, @@ -142,19 +140,6 @@ impl NetworkMetricsRecorder { relay_peers_in_routing_table.clone(), ); - let peers_in_non_full_buckets = Gauge::default(); - sub_registry.register( - "peers_in_non_full_buckets", - "The number of peers in our routing table that are not in full buckets", - peers_in_non_full_buckets.clone(), - ); - let relay_peers_in_non_full_buckets = Gauge::default(); - sub_registry.register( - "relay_peers_in_non_full_buckets", - "The number of relay peers in our routing table that are not in full buckets", - relay_peers_in_non_full_buckets.clone(), - ); - let shunned_count = Counter::default(); sub_registry.register( "shunned_count", @@ -268,8 +253,6 @@ impl NetworkMetricsRecorder { relay_reservation_health, peers_in_routing_table, relay_peers_in_routing_table, - peers_in_non_full_buckets, - relay_peers_in_non_full_buckets, relevant_records, max_records, received_payment_count, From 97aa0810ada0bee51e998bc7462bdc95d1720065 Mon Sep 17 00:00:00 2001 From: qima Date: Fri, 21 Feb 2025 21:57:07 +0800 Subject: [PATCH 6/6] chore(node): rename percentage_of_relay_peers to relay_peers_percentage --- ant-networking/src/event/mod.rs | 2 +- ant-networking/src/metrics/mod.rs | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/ant-networking/src/event/mod.rs b/ant-networking/src/event/mod.rs index 4c98614691..f880c62ee6 100644 --- a/ant-networking/src/event/mod.rs +++ b/ant-networking/src/event/mod.rs @@ -395,7 +395,7 @@ impl SwarmDriver { .estimated_network_size .set(estimated_network_size as i64); - let _ = metrics_recorder.percentage_of_relay_peers.set( + let _ = metrics_recorder.relay_peers_percentage.set( (status.relay_peers_in_non_full_buckets as f64 / status.peers_in_non_full_buckets as f64) * 100.0, diff --git a/ant-networking/src/metrics/mod.rs b/ant-networking/src/metrics/mod.rs index bc78c099de..a1ba7f5b1d 100644 --- a/ant-networking/src/metrics/mod.rs +++ b/ant-networking/src/metrics/mod.rs @@ -43,7 +43,7 @@ pub(crate) struct NetworkMetricsRecorder { pub(crate) connected_peers: Gauge, pub(crate) connected_relay_clients: Gauge, pub(crate) estimated_network_size: Gauge, - pub(crate) percentage_of_relay_peers: Gauge, + pub(crate) relay_peers_percentage: Gauge, pub(crate) open_connections: Gauge, pub(crate) peers_in_routing_table: Gauge, pub(crate) relay_peers_in_routing_table: Gauge, @@ -115,11 +115,11 @@ impl NetworkMetricsRecorder { "The estimated number of nodes in the network calculated by the peers in our RT", estimated_network_size.clone(), ); - let percentage_of_relay_peers = Gauge::::default(); + let relay_peers_percentage = Gauge::::default(); sub_registry.register( - "percentage_of_relay_peers", + "relay_peers_percentage", "The percentage of relay peers in our routing table", - percentage_of_relay_peers.clone(), + relay_peers_percentage.clone(), ); let open_connections = Gauge::default(); sub_registry.register( @@ -246,7 +246,7 @@ impl NetworkMetricsRecorder { records_stored, estimated_network_size, - percentage_of_relay_peers, + relay_peers_percentage, connected_peers, connected_relay_clients, open_connections,