feat: export metrics

package.json

@@ -137,6 +137,7 @@
   "dependencies": {
     "@chainsafe/libp2p-noise": "^11.0.0",
     "@libp2p/interface-connection": "^3.0.2",
+    "@libp2p/interface-metrics": "^4.0.4",
     "@libp2p/interface-peer-id": "^2.0.0",
     "@libp2p/interface-stream-muxer": "^3.0.0",
     "@libp2p/interface-transport": "^2.0.0",
@@ -157,13 +158,14 @@
     "uint8arrays": "^4.0.2"
   },
   "devDependencies": {
-    "@libp2p/interface-mocks": "^9.0.0",
-    "@libp2p/peer-id-factory": "^2.0.0",
-    "@protobuf-ts/plugin": "^2.8.0",
-    "@protobuf-ts/protoc": "^2.8.0",
-    "aegir": "^38.1.6",
+    "@libp2p/interface-mocks": "^9.2.1",
+    "@libp2p/peer-id-factory": "^2.0.2",
+    "@protobuf-ts/plugin": "^2.8.2",
+    "@protobuf-ts/protoc": "^2.8.2",
+    "@types/uuid": "^9.0.1",
+    "aegir": "^38.1.7",
     "eslint-plugin-etc": "^2.0.2",
-    "it-first": "^2.0.0",
-    "libp2p": "^0.41.0"
+    "sinon": "^15.0.2",
+    "sinon-ts": "^1.0.0"
   }
 }

src/maconn.ts

@@ -1,4 +1,5 @@
 import type { MultiaddrConnection, MultiaddrConnectionTimeline } from '@libp2p/interface-connection'
+import type { CounterGroup } from '@libp2p/interface-metrics'
 import { logger } from '@libp2p/logger'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Source, Sink } from 'it-stream-types'
@@ -22,6 +23,11 @@ interface WebRTCMultiaddrConnectionInit {
    * Holds the relevant events timestamps of the connection
    */
   timeline: MultiaddrConnectionTimeline
+
+  /**
+   * Optional metrics counter group for this connection
+   */
+  metrics?: CounterGroup
 }
 
 export class WebRTCMultiaddrConnection implements MultiaddrConnection {
@@ -40,6 +46,11 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
    */
   timeline: MultiaddrConnectionTimeline
 
+  /**
+   * Optional metrics counter group for this connection
+   */
+  metrics?: CounterGroup
+
   /**
    * The stream source, a no-op as the transport natively supports multiplexing
    */
@@ -62,6 +73,7 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
     }
 
     this.timeline.close = new Date().getTime()
+    this.metrics?.increment({ close: true })
     this.peerConnection.close()
   }
 }

src/muxer.ts

@@ -1,27 +1,42 @@
 import type { Stream } from '@libp2p/interface-connection'
+import type { CounterGroup } from '@libp2p/interface-metrics'
 import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface-stream-muxer'
 import type { Source, Sink } from 'it-stream-types'
 
 import { WebRTCStream } from './stream.js'
 import { nopSink, nopSource } from './util.js'
 
+export interface DataChannelMuxerFactoryInit {
+  peerConnection: RTCPeerConnection
+  metrics?: CounterGroup
+}
+
 export class DataChannelMuxerFactory implements StreamMuxerFactory {
   /**
    * WebRTC Peer Connection
    */
   private readonly peerConnection: RTCPeerConnection
 
+  /**
+   * Optional metrics counter group for all incoming/outgoing mux events.
+   */
+  private readonly metrics?: CounterGroup
+
   /**
    * The string representation of the protocol, required by `StreamMuxerFactory`
    */
   protocol: string = '/webrtc'
 
-  constructor (peerConnection: RTCPeerConnection) {
+  constructor (init: DataChannelMuxerFactoryInit) {
+    const { metrics, peerConnection } = init
     this.peerConnection = peerConnection
+    if (metrics != null) {
+      this.metrics = metrics
+    }
   }
 
   createStreamMuxer (init?: StreamMuxerInit | undefined): StreamMuxer {
-    return new DataChannelMuxer(this.peerConnection, init)
+    return new DataChannelMuxer(this.peerConnection, this.metrics, init)
   }
 }
 
@@ -33,6 +48,12 @@ export class DataChannelMuxer implements StreamMuxer {
    * WebRTC Peer Connection
    */
   private readonly peerConnection: RTCPeerConnection
+
+  /**
+   * Optional metrics for this data channel muxer
+   */
+  private readonly metrics?: CounterGroup
+
   /**
    * The protocol as represented in the multiaddress
    */
@@ -63,7 +84,7 @@ export class DataChannelMuxer implements StreamMuxer {
    */
   sink: Sink<Uint8Array, Promise<void>> = nopSink
 
-  constructor (peerConnection: RTCPeerConnection, init?: StreamMuxerInit) {
+  constructor (peerConnection: RTCPeerConnection, metrics?: CounterGroup, init?: StreamMuxerInit) {
     /**
      * Initialized stream muxer
      */
@@ -93,6 +114,7 @@ export class DataChannelMuxer implements StreamMuxer {
       })
 
       if ((init?.onIncomingStream) != null) {
+        this.metrics?.increment({ incoming_stream: true })
         init.onIncomingStream(stream)
       }
     }
@@ -101,6 +123,10 @@ export class DataChannelMuxer implements StreamMuxer {
   newStream (): Stream {
     // The spec says the label SHOULD be an empty string: https://github.com/libp2p/specs/blob/master/webrtc/README.md#rtcdatachannel-label
     const channel = this.peerConnection.createDataChannel('')
+    const closeCb = (stream: WebRTCStream): void => {
+      this.metrics?.increment({ stream_end: true })
+      this.init?.onStreamEnd?.(stream)
+    }
     const stream = new WebRTCStream({
       channel,
       stat: {
@@ -109,7 +135,7 @@ export class DataChannelMuxer implements StreamMuxer {
           open: 0
         }
       },
-      closeCb: this.init?.onStreamEnd
+      closeCb
     })
 
     return stream

src/transport.ts

@@ -12,6 +12,7 @@ import { dataChannelError, inappropriateMultiaddr, unimplemented, invalidArgumen
 import { WebRTCMultiaddrConnection } from './maconn.js'
 import { DataChannelMuxerFactory } from './muxer.js'
 import type { WebRTCDialOptions } from './options.js'
+import type { CounterGroup, Metrics } from '@libp2p/interface-metrics'
 import * as sdp from './sdp.js'
 import { WebRTCStream } from './stream.js'
 import { genUfrag } from './util.js'
@@ -43,16 +44,30 @@ export const CERTHASH_CODE: number = 466
 // @TODO(ddimaria): seems like an unnessary abstraction, consider removing
 export interface WebRTCTransportComponents {
   peerId: PeerId
+  metrics?: Metrics
+}
+
+export interface WebRTCMetrics {
+  dialerEvents: CounterGroup
 }
 
 export class WebRTCTransport implements Transport {
   /**
    * The peer for this transport
    */
   private readonly components: WebRTCTransportComponents
+  private readonly metrics?: WebRTCMetrics
 
   constructor (components: WebRTCTransportComponents) {
     this.components = components
+    if (components.metrics != null) {
+      this.metrics = {
+        dialerEvents: components.metrics.registerCounterGroup('libp2p_webrtc_dialer_events_total', {
+          label: 'event',
+          help: 'Total count of WebRTC dial events by type'
+        })
+      }
+    }
   }
 
   /**
@@ -123,6 +138,7 @@ export class WebRTCTransport implements Transport {
       const handshakeTimeout = setTimeout(() => {
         const error = `Data channel was never opened: state: ${handshakeDataChannel.readyState}`
         log.error(error)
+        this.metrics?.dialerEvents.increment({ openError: true })
         reject(dataChannelError('data', error))
       }, HANDSHAKE_TIMEOUT_MS)
 
@@ -137,6 +153,8 @@ export class WebRTCTransport implements Transport {
         const errorTarget = event.target?.toString() ?? 'not specified'
         const error = `Error opening a data channel for handshaking: ${errorTarget}`
         log.error(error)
+        // NOTE: We use unknown error here but this could potentially be considered a reset by some standards.
+        this.metrics?.dialerEvents.increment({ unknownError: true })
         reject(dataChannelError('data', error))
       }
     })
@@ -189,10 +207,14 @@ export class WebRTCTransport implements Transport {
       remoteAddr: ma,
       timeline: {
         open: (new Date()).getTime()
-      }
+      },
+      metrics: this.metrics?.dialerEvents
     })
 
-    const muxerFactory = new DataChannelMuxerFactory(peerConnection)
+    const muxerFactory = new DataChannelMuxerFactory({
+      peerConnection,
+      metrics: this.metrics?.dialerEvents
+    })
 
     // For outbound connections, the remote is expected to start the noise handshake.
     // Therefore, we need to secure an inbound noise connection from the remote.

test/maconn.browser.spec.ts

@@ -2,25 +2,33 @@
 
 import { multiaddr } from '@multiformats/multiaddr'
 import { expect } from 'aegir/chai'
+import type { CounterGroup } from '@libp2p/interface-metrics'
+import { stubObject } from 'sinon-ts'
 import { WebRTCMultiaddrConnection } from './../src/maconn.js'
 
 describe('Multiaddr Connection', () => {
   it('can open and close', async () => {
     const peerConnection = new RTCPeerConnection()
     peerConnection.createDataChannel('whatever', { negotiated: true, id: 91 })
     const remoteAddr = multiaddr('/ip4/1.2.3.4/udp/1234/webrtc/certhash/uEiAUqV7kzvM1wI5DYDc1RbcekYVmXli_Qprlw3IkiEg6tQ')
+    const metrics = stubObject<CounterGroup>({
+      increment: () => {},
+      reset: () => {}
+    })
     const maConn = new WebRTCMultiaddrConnection({
       peerConnection,
       remoteAddr,
       timeline: {
         open: (new Date()).getTime()
-      }
+      },
+      metrics
     })
 
     expect(maConn.timeline.close).to.be.undefined
 
     await maConn.close()
 
     expect(maConn.timeline.close).to.not.be.undefined
+    expect(metrics.increment.calledWith({ close: true })).to.be.true
   })
 })

test/transport.browser.spec.ts

@@ -1,12 +1,15 @@
 /* eslint-disable @typescript-eslint/no-floating-promises */
 
+import type { Metrics, Metric, MetricGroup, Counter, CounterGroup } from '@libp2p/interface-metrics'
 import * as underTest from './../src/transport.js'
 import { expectError } from './util.js'
 import { UnimplementedError } from './../src/error.js'
+import { stubObject } from 'sinon-ts'
 import { mockUpgrader } from '@libp2p/interface-mocks'
 import { CreateListenerOptions, symbol } from '@libp2p/interface-transport'
 import { multiaddr, Multiaddr } from '@multiformats/multiaddr'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import * as sinon from 'sinon'
 import { expect, assert } from 'aegir/chai'
 
 function ignoredDialOption (): CreateListenerOptions {
@@ -16,10 +19,51 @@ function ignoredDialOption (): CreateListenerOptions {
 
 describe('WebRTC Transport', () => {
   let components: underTest.WebRTCTransportComponents
+  let metrics: Metrics
 
   before(async () => {
+    metrics = stubObject<Metrics>({
+      trackMultiaddrConnection: (maConn) => {},
+      trackProtocolStream: (stream, connection) => {},
+      registerMetric: (name, options) => {
+        return stubObject<Metric>({
+          increment: () => {},
+          reset: () => {},
+          decrement: () => {},
+          update: () => {},
+          timer: () => {
+            return sinon.spy()
+          }
+        })
+      },
+      registerMetricGroup: (name, options) => {
+        return stubObject<MetricGroup>({
+          increment: () => {
+          },
+          reset: () => {},
+          decrement: () => {},
+          update: () => {},
+          timer: () => {
+            return sinon.spy()
+          }
+        })
+      },
+      registerCounter: (name, options) => {
+        return stubObject<Counter>({
+          increment: () => {},
+          reset: () => {}
+        })
+      },
+      registerCounterGroup: (name, options) => {
+        return stubObject<CounterGroup>({
+          increment: () => {},
+          reset: () => {}
+        })
+      }
+    })
     components = {
-      peerId: await createEd25519PeerId()
+      peerId: await createEd25519PeerId(),
+      metrics
     }
   })