Discovery metrics (#1276)

* Silky smooth squash

* Add discovery metrics

* Fix gauge metric, increase discv5 sessions

* Formatting

beacon_node/eth2_libp2p/src/config.rs

@@ -110,7 +110,7 @@ impl Default for Config {
         // discv5 configuration
         let discv5_config = Discv5ConfigBuilder::new()
             .enable_packet_filter()
-            .session_cache_capacity(100)
+            .session_cache_capacity(1000)
             .request_timeout(Duration::from_secs(4))
             .request_retries(2)
             .enr_peer_update_min(2) // prevents NAT's should be raised for mainnet

beacon_node/eth2_libp2p/src/lib.rs

@@ -20,6 +20,7 @@ pub use discv5;
 pub use libp2p::gossipsub::{MessageId, Topic, TopicHash};
 pub use libp2p::{core::ConnectedPoint, PeerId, Swarm};
 pub use libp2p::{multiaddr, Multiaddr};
+pub use metrics::scrape_discovery_metrics;
 pub use peer_manager::discovery;
 pub use peer_manager::{
     client::Client,

beacon_node/eth2_libp2p/src/metrics.rs

@@ -21,8 +21,39 @@ lazy_static! {
         "discovery_queue_size",
         "The number of discovery queries awaiting execution"
     );
-    pub static ref DISCOVERY_REQS: Result<IntGauge> = try_create_int_gauge(
+    pub static ref DISCOVERY_REQS: Result<Gauge> = try_create_float_gauge(
         "discovery_requests",
         "The number of unsolicited discovery requests per second"
     );
+    pub static ref DISCOVERY_SESSIONS: Result<IntGauge> = try_create_int_gauge(
+        "discovery_sessions",
+        "The number of active discovery sessions with peers"
+    );
+    pub static ref DISCOVERY_REQS_IP: Result<GaugeVec> = try_create_float_gauge_vec(
+        "discovery_reqs_per_ip",
+        "Unsolicited discovery requests per ip per second",
+        &["Addresses"]
+    );
+}
+
+pub fn scrape_discovery_metrics() {
+    let metrics = discv5::metrics::Metrics::from(discv5::Discv5::raw_metrics());
+
+    set_float_gauge(&DISCOVERY_REQS, metrics.unsolicited_requests_per_second);
+
+    set_gauge(&DISCOVERY_SESSIONS, metrics.active_sessions as i64);
+
+    let process_gauge_vec = |gauge: &Result<GaugeVec>, metrics: discv5::metrics::Metrics| {
+        if let Ok(gauge_vec) = gauge {
+            gauge_vec.reset();
+            for (ip, value) in metrics.requests_per_ip_per_second.iter() {
+                if let Ok(metric) = gauge_vec.get_metric_with_label_values(&[&format!("{:?}", ip)])
+                {
+                    metric.set(*value);
+                }
+            }
+        }
+    };
+
+    process_gauge_vec(&DISCOVERY_REQS_IP, metrics);
 }

beacon_node/eth2_libp2p/src/peer_manager/discovery/mod.rs

@@ -12,9 +12,8 @@ use crate::{error, Enr, NetworkConfig, NetworkGlobals};
 use discv5::{enr::NodeId, Discv5, Discv5Event};
 use enr::{BITFIELD_ENR_KEY, ETH2_ENR_KEY};
 use futures::prelude::*;
-use libp2p::core::PeerId;
-// use libp2p::multiaddr::Protocol;
 use futures::stream::FuturesUnordered;
+use libp2p::core::PeerId;
 use lru::LruCache;
 use slog::{crit, debug, info, trace, warn};
 use ssz::{Decode, Encode};
@@ -197,11 +196,11 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
             });
         }
 
-        // start the discv5 service.
+        // Start the discv5 service.
         discv5.start(listen_socket);
         debug!(log, "Discovery service started");
 
-        // obtain the event stream
+        // Obtain the event stream
         let event_stream = EventStream::Awaiting(Box::pin(discv5.event_stream()));
 
         Ok(Self {
@@ -224,6 +223,10 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
 
     /// This adds a new `FindPeers` query to the queue if one doesn't already exist.
     pub fn discover_peers(&mut self) {
+        // If we are in the process of a query, don't bother queuing a new one.
+        if self.find_peer_active {
+            return;
+        }
         // If there is not already a find peer's query queued, add one
         let query = QueryType::FindPeers;
         if !self.queued_queries.contains(&query) {
@@ -426,6 +429,8 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
                 None => {} // Queue is empty
             }
         }
+        // Update the queue metric
+        metrics::set_gauge(&metrics::DISCOVERY_QUEUE, self.queued_queries.len() as i64);
     }
 
     // Returns a boolean indicating if we are currently processing the maximum number of