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

misc/metrics/CHANGELOG.md

@@ -16,6 +16,10 @@
 
 - Update to `libp2p-gossipsub` `v0.43.0`.
 
+- Add `protocol_stack` metrics. See [PR 2982].
+
+[PR 2982]: https://github.com/libp2p/rust-libp2p/pull/2982/
+
 # 0.10.0
 
 - Update to `libp2p-swarm` `v0.40.0`.
@@ -147,7 +151,6 @@
 - Drop support for gossipsub in wasm32-unknown-unknown target (see [PR 2506]).
 
 [PR 2442]: https://github.com/libp2p/rust-libp2p/pull/2442
-
 [PR 2506]: https://github.com/libp2p/rust-libp2p/pull/2506
 
 # 0.3.0 [2022-01-27]

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;
@@ -68,11 +68,12 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     let local_key = identity::Keypair::generate_ed25519();
     let local_peer_id = PeerId::from(local_key.public());
+    let local_pub_key = local_key.public();
     info!("Local peer id: {:?}", local_peer_id);
 
     let mut swarm = Swarm::new(
         block_on(libp2p::development_transport(local_key))?,
-        Behaviour::default(),
+        Behaviour::new(local_pub_key),
         local_peer_id,
     );
 
@@ -95,6 +96,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 +114,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_pub_key: libp2p::identity::PublicKey) -> Self {
+        Self {
+            ping: ping::Behaviour::default(),
+            identify: identify::Behaviour::new(identify::Config::new(
+                "/ipfs/0.1.0".into(),
+                local_pub_key,
+            )),
+            keep_alive: keep_alive::Behaviour::default(),
+        }
+    }
+}

misc/metrics/src/identify.rs

@@ -18,9 +18,11 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
+use crate::protocol_stack;
 use libp2p_core::PeerId;
 use prometheus_client::encoding::text::{EncodeMetric, Encoder};
 use prometheus_client::metrics::counter::Counter;
+use prometheus_client::metrics::family::Family;
 use prometheus_client::metrics::histogram::{exponential_buckets, Histogram};
 use prometheus_client::metrics::MetricType;
 use prometheus_client::registry::Registry;
@@ -36,6 +38,7 @@ pub struct Metrics {
     received_info_listen_addrs: Histogram,
     received_info_protocols: Histogram,
     sent: Counter,
+    listen_addresses: Family<protocol_stack::Labels, 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,11 @@ 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(&protocol_stack::Labels::new(&listen_addr))
+                        .inc();
+                }
             }
             libp2p_identify::Event::Sent { .. } => {
                 self.sent.inc();

misc/metrics/src/lib.rs

@@ -38,6 +38,7 @@ mod identify;
 mod kad;
 #[cfg(feature = "ping")]
 mod ping;
+mod protocol_stack;
 #[cfg(feature = "relay")]
 mod relay;
 mod swarm;

misc/metrics/src/protocol_stack.rs

@@ -0,0 +1,91 @@
+use libp2p_core::multiaddr::{Multiaddr, Protocol};
+use prometheus_client::encoding::text::Encode;
+
+#[derive(Encode, Hash, Clone, Eq, PartialEq)]
+pub struct Labels {
+    protocols: String,
+}
+
+impl Labels {
+    pub fn new(ma: &Multiaddr) -> Self {
+        Self {
+            protocols: ma.protocol_stack(),
+        }
+    }
+}
+
+//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.
+pub 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
+    }
+}
+
+fn tag(proto: Protocol) -> &'static str {
+    use Protocol::*;
+    match proto {
+        Certhash(_) => "certhash",
+        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",
+        Noise => "noise",
+        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",
+        WebRTC => "webrtc",
+        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 = Labels::for_multi_address(&ma);
+        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, r#"address_stack="/ip6/tcp/wss/p2p""#);
+    }
+}