misc/metrics: Add protocols label to address-specific metrics

misc/metrics/examples/metrics/main.rs

@@ -54,7 +54,7 @@ use futures::stream::StreamExt;
 use libp2p::core::Multiaddr;
 use libp2p::metrics::{Metrics, Recorder};
 use libp2p::swarm::SwarmEvent;
-use libp2p::{identity, ping, NetworkBehaviour, PeerId, Swarm};
+use libp2p::{identify, identity, ping, NetworkBehaviour, PeerId, Swarm};
 use libp2p_swarm::keep_alive;
 use log::info;
 use prometheus_client::registry::Registry;
@@ -71,8 +71,8 @@ fn main() -> Result<(), Box<dyn Error>> {
     info!("Local peer id: {:?}", local_peer_id);
 
     let mut swarm = Swarm::new(
-        block_on(libp2p::development_transport(local_key))?,
-        Behaviour::default(),
+        block_on(libp2p::development_transport(local_key.clone()))?,
+        Behaviour::new(local_key),
         local_peer_id,
     );
 
@@ -95,6 +95,10 @@ fn main() -> Result<(), Box<dyn Error>> {
                     info!("{:?}", ping_event);
                     metrics.record(&ping_event);
                 }
+                SwarmEvent::Behaviour(BehaviourEvent::Identify(identify_event)) => {
+                    info!("{:?}", identify_event);
+                    metrics.record(&identify_event);
+                }
                 swarm_event => {
                     info!("{:?}", swarm_event);
                     metrics.record(&swarm_event);
@@ -109,8 +113,22 @@ fn main() -> Result<(), Box<dyn Error>> {
 ///
 /// For illustrative purposes, this includes the [`keep_alive::Behaviour`]) behaviour so the ping actually happen
 /// and can be observed via the metrics.
-#[derive(NetworkBehaviour, Default)]
+#[derive(NetworkBehaviour)]
 struct Behaviour {
+    identify: identify::Behaviour,
     keep_alive: keep_alive::Behaviour,
     ping: ping::Behaviour,
 }
+
+impl Behaviour{
+    fn new(local_key: libp2p::identity::Keypair) -> Self {
+        Self{
+            ping: ping::Behaviour::default(),
+            identify: identify::Behaviour::new( identify::Config::new(
+                "/ipfs/0.1.0".into(),
+                local_key.public(),
+            )),
+            keep_alive: keep_alive::Behaviour::default(),
+        }
+    }
+}

misc/metrics/src/identify.rs

@@ -27,6 +27,8 @@ use prometheus_client::registry::Registry;
 use std::collections::HashMap;
 use std::iter;
 use std::sync::{Arc, Mutex};
+use prometheus_client::metrics::family::Family;
+use crate::protocol_stack;
 
 pub struct Metrics {
     protocols: Protocols,
@@ -36,6 +38,7 @@ pub struct Metrics {
     received_info_listen_addrs: Histogram,
     received_info_protocols: Histogram,
     sent: Counter,
+    listen_addresses: Family<protocol_stack::Label, Counter>,
 }
 
 impl Metrics {
@@ -100,6 +103,13 @@ impl Metrics {
             Box::new(sent.clone()),
         );
 
+        let listen_addresses = Family::default();
+        sub_registry.register(
+            "listen_addresses",
+            "Number of listen addresses for remote peer per protocol stack",
+            Box::new(listen_addresses.clone())
+        );
+
         Self {
             protocols,
             error,
@@ -108,6 +118,7 @@ impl Metrics {
             received_info_listen_addrs,
             received_info_protocols,
             sent,
+            listen_addresses
         }
     }
 }
@@ -167,6 +178,9 @@ impl super::Recorder<libp2p_identify::Event> for Metrics {
                     .observe(info.protocols.len() as f64);
                 self.received_info_listen_addrs
                     .observe(info.listen_addrs.len() as f64);
+                for listen_addr in &info.listen_addrs {
+                    self.listen_addresses.get_or_create(&listen_addr.into()).inc();
+                }
             }
             libp2p_identify::Event::Sent { .. } => {
                 self.sent.inc();

misc/metrics/src/lib.rs

@@ -39,6 +39,7 @@ mod ping;
 #[cfg(feature = "relay")]
 mod relay;
 mod swarm;
+mod protocol_stack;
 
 use prometheus_client::registry::Registry;
 

misc/metrics/src/protocol_stack.rs

@@ -0,0 +1,89 @@
+use prometheus_client::encoding::text::Encode;
+use libp2p_core::multiaddr::{Multiaddr,Protocol};
+
+//TODO: remove this trait and tag() and replace with calls to the upstream method
+//  once that lands : https://github.com/multiformats/rust-multiaddr/pull/60
+// In the meantime there is no _ case in the match so one can easily detect mismatch in supported
+//  protocols when dependency version changes.
+trait MultiaddrExt {
+    fn protocol_stack(&self) -> String;
+}
+impl MultiaddrExt for Multiaddr {
+    fn protocol_stack(&self) -> String {
+        // Has potential to allocate multiple times, but this line expresses the intent here.
+        //  std::iter::once("/").chain(ma.iter().map(tag).intersperse("/")).collect()
+        let len = self.iter().fold(0, |acc, proto| acc + tag(proto).len() + 1);
+        let mut result = String::with_capacity(len);
+        for proto_tag in self.iter().map(tag) {
+            result.push('/');
+            result.push_str(proto_tag);
+        }
+        result
+    }
+}
+
+#[derive(Encode, Hash, Clone, Eq, PartialEq)]
+pub struct Label {
+    address_stack: String
+}
+impl From<Multiaddr> for Label {
+    fn from(ma: Multiaddr) -> Self {
+       Self:: from(&ma)
+    }
+}
+impl From<&Multiaddr> for Label {
+     fn from(ma: &Multiaddr) -> Self {
+        Self { address_stack: ma.protocol_stack() }
+    }
+}
+
+pub fn tag(proto: Protocol) -> &'static str {
+    use Protocol::*;
+    match proto {
+        Dccp(_) => "dccp",
+        Dns(_) => "dns",
+        Dns4(_) => "dns4",
+        Dns6(_) => "dns6",
+        Dnsaddr(_) => "dnsaddr",
+        Http => "http",
+        Https => "https",
+        Ip4(_) => "ip4",
+        Ip6(_) => "ip6",
+        P2pWebRtcDirect => "p2p-webrtc-direct",
+        P2pWebRtcStar => "p2p-webrtc-star",
+        P2pWebSocketStar => "p2p-websocket-star",
+        Memory(_) => "memory",
+        Onion(_, _) => "onion",
+        Onion3(_) => "onion3",
+        P2p(_) => "p2p",
+        P2pCircuit => "p2p-circuit",
+        Quic => "quic",
+        Sctp(_) => "sctp",
+        Tcp(_) => "tcp",
+        Tls => "tls",
+        Udp(_) => "udp",
+        Udt => "udt",
+        Unix(_) => "unix",
+        Utp => "utp",
+        Ws(ref s) if s == "/" => "ws",
+        Ws(_) => "x-parity-ws",
+        Wss(ref s) if s == "/" => "wss",
+        Wss(_) => "x-parity-wss",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ip6_tcp_wss_p2p() {
+        let ma = Multiaddr::try_from("/ip6/2001:8a0:7ac5:4201:3ac9:86ff:fe31:7095/tcp/8000/wss/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC").expect("testbad");
+        let actual : Label = ma.into();
+        assert_eq!(actual.address_stack,"/ip6/tcp/wss/p2p");
+        let mut buf = Vec::new();
+        actual.encode(&mut buf).expect("encode failed");
+        let actual = String::from_utf8(buf).expect("invalid utf-8?");
+        assert_eq!(actual, "address_stack=\"/ip6/tcp/wss/p2p\"");
+    }
+}

misc/metrics/src/swarm.rs

@@ -22,9 +22,10 @@ use prometheus_client::encoding::text::Encode;
 use prometheus_client::metrics::counter::Counter;
 use prometheus_client::metrics::family::Family;
 use prometheus_client::registry::Registry;
+use crate::protocol_stack;
 
 pub struct Metrics {
-    connections_incoming: Counter,
+    connections_incoming: Family<protocol_stack::Label, Counter>,
     connections_incoming_error: Family<IncomingConnectionErrorLabels, Counter>,
 
     connections_established: Family<ConnectionEstablishedLabels, Counter>,
@@ -45,10 +46,10 @@ impl Metrics {
     pub fn new(registry: &mut Registry) -> Self {
         let sub_registry = registry.sub_registry_with_prefix("swarm");
 
-        let connections_incoming = Counter::default();
+        let connections_incoming = Family::default();
         sub_registry.register(
             "connections_incoming",
-            "Number of incoming connections",
+            "Number of incoming connections per address stack",
             Box::new(connections_incoming.clone()),
         );
 
@@ -156,8 +157,8 @@ impl<TBvEv, THandleErr> super::Recorder<libp2p_swarm::SwarmEvent<TBvEv, THandleE
                     })
                     .inc();
             }
-            libp2p_swarm::SwarmEvent::IncomingConnection { .. } => {
-                self.connections_incoming.inc();
+            libp2p_swarm::SwarmEvent::IncomingConnection { send_back_addr, .. } => {
+                self.connections_incoming.get_or_create(&send_back_addr.into()).inc();
             }
             libp2p_swarm::SwarmEvent::IncomingConnectionError { error, .. } => {
                 self.connections_incoming_error