@libp2p/devtools-metrics 0.2.0 → 0.2.1

package/src/index.ts

@@ -17,11 +17,22 @@
  */
 
 import { serviceCapabilities, start, stop } from '@libp2p/interface'
-import { enable, disable } from '@libp2p/logger'
 import { simpleMetrics } from '@libp2p/simple-metrics'
+import { pipe } from 'it-pipe'
+import { pushable } from 'it-pushable'
+import { rpc, type RPC } from 'it-rpc'
 import { base64 } from 'multiformats/bases/base64'
-import type { ComponentLogger, Connection, Libp2pEvents, Logger, Metrics, MultiaddrConnection, PeerId, Peer as PeerStorePeer, PeerStore, PeerUpdate, Stream, TypedEventTarget } from '@libp2p/interface'
-import type { TransportManager, Registrar, ConnectionManager } from '@libp2p/interface-internal'
+import { valueCodecs } from './rpc/index.js'
+import { metricsRpc } from './rpc/rpc.js'
+import { debounce } from './utils/debounce.js'
+import { getPeers } from './utils/get-peers.js'
+import { getSelf } from './utils/get-self.js'
+import type { DevToolsRPC } from './rpc/index.js'
+import type { ComponentLogger, Connection, Libp2pEvents, Logger, Metrics, MultiaddrConnection, PeerId, PeerStore, Stream, ContentRouting, PeerRouting, TypedEventTarget, Startable } from '@libp2p/interface'
+import type { TransportManager, Registrar, ConnectionManager, AddressManager } from '@libp2p/interface-internal'
+import type { Pushable } from 'it-pushable'
+
+export * from './rpc/index.js'
 
 export const SOURCE_DEVTOOLS = '@libp2p/devtools-metrics:devtools'
 export const SOURCE_SERVICE_WORKER = '@libp2p/devtools-metrics:worker'
@@ -36,39 +47,12 @@ Object.defineProperty(globalThis, LIBP2P_DEVTOOLS_METRICS_KEY, {
   writable: false
 })
 
-/**
- * Sent when new metrics are available
- */
-export interface MetricsMessage {
-  source: typeof SOURCE_METRICS
-  type: 'metrics'
-  metrics: Record<string, any>
-}
-
-/**
- * This message represents the current state of the libp2p node
- */
-export interface SelfMessage {
-  source: typeof SOURCE_METRICS
-  type: 'self'
-  peer: SelfPeer
-}
-
-/**
- * This message represents the current state of the libp2p node
- */
-export interface PeersMessage {
-  source: typeof SOURCE_METRICS
-  type: 'peers'
-  peers: Peer[]
-}
-
 /**
  * Sent by the DevTools service worker to the DevTools panel when the inspected
  * page has finished (re)loading
  */
 export interface PageLoadedMessage {
-  source: '@libp2p/devtools-metrics:devtools'
+  source: typeof SOURCE_DEVTOOLS
   type: 'page-loaded'
   tabId: number
 }
@@ -81,47 +65,40 @@ export interface PageLoadedMessage {
  * not having granted permission for the script to run.
  */
 export interface PermissionsErrorMessage {
-  source: '@libp2p/devtools-metrics:devtools'
+  source: typeof SOURCE_DEVTOOLS
   type: 'permissions-error'
   tabId: number
 }
 
 /**
- * This message is sent by DevTools when no `self` message has been received
+ * This event is intercepted by the service worker which injects a content
+ * script into the current page which copies the passed value to the clipboard.
  */
-export interface IdentifyMessage {
-  source: '@libp2p/devtools-metrics:devtools'
-  type: 'identify'
+export interface CopyToClipboardMessage {
+  source: typeof SOURCE_DEVTOOLS
+  type: 'copy-to-clipboard'
   tabId: number
+  value: string
 }
 
 /**
- * This message is sent by DevTools when no `self` message has been received
+ * Invoke a method on the libp2p object
  */
-export interface EnableDebugMessage {
-  source: '@libp2p/devtools-metrics:devtools'
-  type: 'debug'
-  namespace: string
+export interface RPCMessage {
+  source: typeof SOURCE_DEVTOOLS | typeof SOURCE_METRICS
+  type: 'libp2p-rpc'
   tabId: number
-}
 
-/**
- * We cannot use the web extension API to copy text to the cliboard yet as it's
- * not supported in Firefox yet, so get the page to do it
- *
- * @see https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Interact_with_the_clipboard#writing_to_the_clipboard
- */
-export interface CopyToClipboardMessage {
-  source: '@libp2p/devtools-metrics:devtools'
-  type: 'copy-to-clipboard'
-  value: string
-  tabId: number
+  /**
+   * The RPC message encoded as a multibase string
+   */
+  message: string
 }
 
 /**
  * Messages that are sent from the application page to the DevTools panel
  */
-export type ApplicationMessage = MetricsMessage | SelfMessage | PeersMessage
+export type ApplicationMessage = RPCMessage
 
 /**
  * Messages that are sent from the service worker
@@ -131,34 +108,7 @@ export type WorkerMessage = PageLoadedMessage | PermissionsErrorMessage
 /**
  * Messages that are sent from the DevTools panel page to the application page
  */
-export type DevToolsMessage = IdentifyMessage | EnableDebugMessage | CopyToClipboardMessage
-
-export interface SelfPeer {
-  /**
-   * The identifier of the peer
-   */
-  id: string
-
-  /**
-   * The list of multiaddrs the peer is listening on
-   */
-  multiaddrs: string[]
-
-  /**
-   * Any peer store tags the peer has
-   */
-  tags: Record<string, number>
-
-  /**
-   * Any peer store metadata the peer has
-   */
-  metadata: Record<string, string>
-
-  /**
-   * The protocols the peer supports
-   */
-  protocols: string[]
-}
+export type DevToolsMessage = CopyToClipboardMessage | RPCMessage
 
 export interface Address {
   /**
@@ -178,33 +128,6 @@ export interface Address {
   isConnected?: boolean
 }
 
-export interface Peer {
-  /**
-   * The identifier of the remote peer
-   */
-  id: string
-
-  /**
-   * The list of addresses the peer has that we know about
-   */
-  addresses: Address[]
-
-  /**
-   * Any peer store tags the peer has
-   */
-  tags: Record<string, number>
-
-  /**
-   * Any peer store metadata the peer has
-   */
-  metadata: Record<string, string>
-
-  /**
-   * The protocols the peer supports, if known
-   */
-  protocols: string[]
-}
-
 export interface DevToolsMetricsInit {
   /**
    * How often to pass metrics to the DevTools panel
@@ -220,36 +143,47 @@ export interface DevToolsMetricsComponents {
   registrar: Registrar
   connectionManager: ConnectionManager
   peerStore: PeerStore
+
+  contentRouting: ContentRouting
+  peerRouting: PeerRouting
+  addressManager: AddressManager
 }
 
-class DevToolsMetrics implements Metrics {
+class DevToolsMetrics implements Metrics, Startable {
   private readonly log: Logger
   private readonly components: DevToolsMetricsComponents
   private readonly simpleMetrics: Metrics
   private readonly intervalMs?: number
+  private readonly rpcQueue: Pushable<Uint8Array>
+  private readonly rpc: RPC
+  private readonly devTools: DevToolsRPC
 
   constructor (components: DevToolsMetricsComponents, init?: Partial<DevToolsMetricsInit>) {
     this.log = components.logger.forComponent('libp2p:devtools-metrics')
     this.intervalMs = init?.intervalMs
     this.components = components
 
+    // create RPC endpoint
+    this.rpcQueue = pushable()
+    this.rpc = rpc({
+      valueCodecs
+    })
+    this.devTools = this.rpc.createClient('devTools')
+
     // collect information on current peers and sent it to the dev tools panel
     this.onPeersUpdate = debounce(this.onPeersUpdate.bind(this), 1000)
-    this.onSelfUpdate = this.onSelfUpdate.bind(this)
+    this.onSelfUpdate = debounce(this.onSelfUpdate.bind(this), 1000)
     this.onIncomingMessage = this.onIncomingMessage.bind(this)
 
     // collect metrics
     this.simpleMetrics = simpleMetrics({
       intervalMs: this.intervalMs,
       onMetrics: (metrics) => {
-        const message: MetricsMessage = {
-          source: SOURCE_METRICS,
-          type: 'metrics',
-          metrics
-        }
-
-        this.log('post metrics message')
-        window.postMessage(message, '*')
+        this.devTools.safeDispatchEvent('metrics', {
+          detail: metrics
+        }).catch(err => {
+          this.log.error('error sending metrics', err)
+        })
       }
     })({})
   }
@@ -297,8 +231,32 @@ class DevToolsMetrics implements Metrics {
     // process incoming messages from devtools
     window.addEventListener('message', this.onIncomingMessage)
 
+    // create rpc target
+    this.rpc.createTarget('metrics', metricsRpc(this.components))
+
     // send metrics
     await start(this.simpleMetrics)
+
+    // send RPC messages
+    Promise.resolve()
+      .then(async () => {
+        await pipe(
+          this.rpcQueue,
+          this.rpc,
+          async source => {
+            for await (const buf of source) {
+              window.postMessage({
+                source: SOURCE_METRICS,
+                type: 'libp2p-rpc',
+                message: base64.encode(buf)
+              })
+            }
+          }
+        )
+      })
+      .catch(err => {
+        this.log.error('error while reading RPC messages', err)
+      })
   }
 
   async stop (): Promise<void> {
@@ -311,90 +269,6 @@ class DevToolsMetrics implements Metrics {
     await stop(this.simpleMetrics)
   }
 
-  private onPeersUpdate (): void {
-    Promise.resolve().then(async () => {
-      const message: PeersMessage = {
-        source: SOURCE_METRICS,
-        type: 'peers',
-        peers: []
-      }
-
-      const connections = this.components.connectionManager.getConnectionsMap()
-      const connectedAddresses = [...connections.values()].flatMap(conn => conn).map(conn => conn.remoteAddr.toString())
-
-      for (const [peerId, conns] of connections.entries()) {
-        try {
-          const peer = await this.components.peerStore.get(peerId)
-
-          message.peers.push({
-            id: peerId.toString(),
-            addresses: peer.addresses.map(({ isCertified, multiaddr }) => {
-              const addr = multiaddr.toString()
-
-              return {
-                multiaddr: addr,
-                isCertified,
-                isConnected: connectedAddresses.includes(addr)
-              }
-            }),
-            protocols: [...peer.protocols],
-            tags: toObject(peer.tags, (t) => t.value),
-            metadata: toObject(peer.metadata, (buf) => base64.encode(buf))
-          })
-        } catch (err) {
-          this.log.error('could not load peer data from peer store', err)
-
-          message.peers.push({
-            id: peerId.toString(),
-            addresses: conns.map(conn => {
-              const addr = conn.remoteAddr.toString()
-
-              return {
-                multiaddr: addr,
-                isConnected: connectedAddresses.includes(addr)
-              }
-            }),
-            protocols: [],
-            tags: {},
-            metadata: {}
-          })
-        }
-      }
-
-      window.postMessage(message, '*')
-    })
-      .catch(err => {
-        this.log.error('error sending peers message', err)
-      })
-  }
-
-  private onSelfUpdate (evt: CustomEvent<PeerUpdate>): void {
-    this.sendSelfUpdate(evt.detail.peer)
-  }
-
-  private sendSelfUpdate (peer: PeerStorePeer): void {
-    Promise.resolve()
-      .then(async () => {
-        const message: SelfMessage = {
-          source: SOURCE_METRICS,
-          type: 'self',
-          peer: {
-            id: peer.id.toString(),
-            multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr.toString()),
-            protocols: [...peer.protocols],
-            tags: toObject(peer.tags, (t) => t.value),
-            metadata: toObject(peer.metadata, (buf) => base64.encode(buf))
-          }
-        }
-
-        this.log('post node update message')
-        window.postMessage(message, '*')
-      })
-      .catch(err => {
-        this.log.error('error sending self update', err)
-      })
-  }
-
   private onIncomingMessage (event: MessageEvent<DevToolsMessage>): void {
     // Only accept messages from same frame
     if (event.source !== window) {
@@ -408,29 +282,33 @@ class DevToolsMetrics implements Metrics {
       return
     }
 
-    // respond to identify request
-    if (message.type === 'identify') {
-      Promise.resolve()
-        .then(async () => {
-          const peer = await this.components.peerStore.get(this.components.peerId)
+    if (message.type === 'libp2p-rpc') {
+      this.rpcQueue.push(base64.decode(message.message))
+    }
+  }
 
-          this.sendSelfUpdate(peer)
-          // also send our current peer list
-          this.onPeersUpdate()
-        })
-        .catch(err => {
-          this.log.error('error sending identify response', err)
+  private onSelfUpdate (): void {
+    Promise.resolve()
+      .then(async () => {
+        await this.devTools.safeDispatchEvent('self', {
+          detail: await getSelf(this.components)
         })
-    }
+      })
+      .catch(err => {
+        this.log.error('error sending peers message', err)
+      })
+  }
 
-    // handle enabling/disabling debug namespaces
-    if (message.type === 'debug') {
-      if (message.namespace.length > 0) {
-        enable(message.namespace)
-      } else {
-        disable()
-      }
-    }
+  private onPeersUpdate (): void {
+    Promise.resolve()
+      .then(async () => {
+        await this.devTools.safeDispatchEvent('peers', {
+          detail: await getPeers(this.components, this.log)
+        })
+      })
+      .catch(err => {
+        this.log.error('error sending peers message', err)
+      })
   }
 }
 
@@ -439,37 +317,3 @@ export function devToolsMetrics (init?: Partial<DevToolsMetricsInit>): (componen
     return new DevToolsMetrics(components, init)
   }
 }
-
-function toObject <T, R> (map: Map<string, T>, transform: (value: T) => R): Record<string, R> {
-  const output: Record<string, any> = {}
-
-  for (const [key, value] of map.entries()) {
-    output[key] = transform(value)
-  }
-
-  return output
-}
-
-function debounce (callback: () => void, wait: number = 100): () => void {
-  let timeout: ReturnType<typeof setTimeout>
-  let start: number | undefined
-
-  return (): void => {
-    if (start == null) {
-      start = Date.now()
-    }
-
-    if (timeout != null && Date.now() - start > wait) {
-      clearTimeout(timeout)
-      start = undefined
-      callback()
-      return
-    }
-
-    clearTimeout(timeout)
-    timeout = setTimeout(() => {
-      start = undefined
-      callback()
-    }, wait)
-  }
-}

package/src/rpc/codecs/cid.ts

@@ -0,0 +1,9 @@
+import { CID } from 'multiformats/cid'
+import type { ValueCodec } from 'it-rpc'
+
+export const cidCodec: ValueCodec<CID> = {
+  type: 4096,
+  canEncode: (val) => val.code != null && val.version != null && val.multihash != null && val['/'] != null,
+  encode: (val) => val.bytes,
+  decode: (buf) => CID.decode(buf)
+}

package/src/rpc/codecs/custom-progress-event.ts

@@ -0,0 +1,17 @@
+import { encode, decode } from 'cborg'
+import { CustomProgressEvent } from 'progress-events'
+import type { ValueCodec } from 'it-rpc'
+
+export const customProgressEventCodec: ValueCodec<CustomProgressEvent> = {
+  type: 4099,
+  canEncode: (val) => val instanceof CustomProgressEvent,
+  encode: (val, codec, context, invocation) => encode({
+    type: val.type,
+    detail: codec.toValue(val.detail, context, invocation)
+  }),
+  decode: (val, codec, pushable, invocation) => {
+    const { type, detail } = decode(val)
+
+    return new CustomProgressEvent(type, codec.fromValue(detail, pushable, invocation))
+  }
+}

package/src/rpc/codecs/multiaddr.ts

@@ -0,0 +1,10 @@
+import { isMultiaddr, multiaddr } from '@multiformats/multiaddr'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { ValueCodec } from 'it-rpc'
+
+export const multiaddrCodec: ValueCodec<Multiaddr> = {
+  type: 4097,
+  canEncode: (val) => isMultiaddr(val),
+  encode: (val) => val.bytes,
+  decode: (buf) => multiaddr(buf)
+}

package/src/rpc/codecs/peer-id.ts

@@ -0,0 +1,11 @@
+import { isPeerId } from '@libp2p/interface'
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import type { PeerId } from '@libp2p/interface'
+import type { ValueCodec } from 'it-rpc'
+
+export const peerIdCodec: ValueCodec<PeerId> = {
+  type: 4098,
+  canEncode: (val) => isPeerId(val),
+  encode: (val) => val.toBytes(),
+  decode: (buf) => peerIdFromBytes(buf)
+}

package/src/rpc/index.ts

@@ -0,0 +1,122 @@
+import { cidCodec } from './codecs/cid.js'
+import { customProgressEventCodec } from './codecs/custom-progress-event.js'
+import { multiaddrCodec } from './codecs/multiaddr.js'
+import { peerIdCodec } from './codecs/peer-id.js'
+import type { ContentRouting, PeerId, PeerRouting, AbortOptions } from '@libp2p/interface'
+import type { OpenConnectionOptions } from '@libp2p/interface-internal'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { ValueCodec } from 'it-rpc'
+
+export const valueCodecs: Array<ValueCodec<any>> = [
+  cidCodec,
+  multiaddrCodec,
+  peerIdCodec,
+  customProgressEventCodec
+]
+
+export interface NodeAddress {
+  multiaddr: Multiaddr
+  listen?: boolean
+  announce?: boolean
+  observed?: boolean
+  default?: boolean
+}
+
+export interface NodeStatus {
+  peerId: PeerId
+  agent?: string
+  addresses: NodeAddress[]
+  protocols: string[]
+}
+
+export interface PeerAddress {
+  multiaddr: Multiaddr
+  isConnected?: boolean
+  isCertified?: boolean
+}
+
+export interface Peer {
+  /**
+   * The identifier of the remote peer
+   */
+  id: PeerId
+
+  /**
+   * The list of addresses the peer has that we know about
+   */
+  addresses: PeerAddress[]
+
+  /**
+   * Any peer store tags the peer has
+   */
+  tags: Record<string, number>
+
+  /**
+   * Any peer store metadata the peer has
+   */
+  metadata: Record<string, string>
+
+  /**
+   * The protocols the peer supports, if known
+   */
+  protocols: string[]
+}
+
+/**
+ * RPC operations exposed by the metrics
+ */
+export interface MetricsRPC {
+  /**
+   * Called by DevTools on initial connect
+   */
+  init(options?: AbortOptions): Promise<{ self: Peer, peers: Peer[], debug: string }>
+
+  /**
+   * Update the currently active debugging namespaces
+   */
+  setDebug(namespace?: string): Promise<void>
+
+  /**
+   * Open a connection to the passed peer or multiaddr
+   */
+  openConnection(peerIdOrMultiaddr: string, options?: OpenConnectionOptions): Promise<void>
+
+  /**
+   * Close connections open to the specified peer
+   */
+  closeConnection(peerId: PeerId, options?: AbortOptions): Promise<void>
+
+  /**
+   * Make content routing queries
+   */
+  contentRouting: ContentRouting
+
+  /**
+   * Make peer routing queries
+   */
+  peerRouting: PeerRouting
+}
+
+export interface DevToolsEvents {
+  /**
+   * Node metrics have been updated
+   */
+  'metrics': CustomEvent<Record<string, any>>
+
+  /**
+   * The node's status has changed - new addresses and/or protocols, etc
+   */
+  'self': CustomEvent<Peer>
+
+  /**
+   * The node's connected peers have changed
+   */
+  'peers': CustomEvent<Peer[]>
+}
+
+/**
+ * RPC operations exposed by the DevTools
+ */
+export interface DevToolsRPC {
+  safeDispatchEvent<Detail>(type: keyof DevToolsEvents, detail?: CustomEventInit<Detail>): Promise<void>
+}