@libp2p/devtools-metrics 0.2.0 → 0.2.1

package/src/rpc/rpc.ts

@@ -0,0 +1,59 @@
+import { enable, disable } from '@libp2p/logger'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { multiaddr } from '@multiformats/multiaddr'
+import { getPeers } from '../utils/get-peers.js'
+import { getSelf } from '../utils/get-self.js'
+import type { MetricsRPC } from './index.js'
+import type { DevToolsMetricsComponents } from '../index.js'
+import type { PeerId } from '@libp2p/interface'
+import type { OpenConnectionOptions } from '@libp2p/interface-internal'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { AbortOptions } from 'it-pushable'
+
+export function metricsRpc (components: DevToolsMetricsComponents): MetricsRPC {
+  const log = components.logger.forComponent('libp2p:devtools-metrics:metrics-rpc')
+
+  return {
+    init: async () => {
+      return {
+        self: await getSelf(components),
+        peers: await getPeers(components, log),
+        debug: localStorage.getItem('debug') ?? ''
+      }
+    },
+    setDebug: async (namespace?: string) => {
+      if (namespace?.length != null && namespace?.length > 0) {
+        enable(namespace)
+        localStorage.setItem('debug', namespace)
+      } else {
+        disable()
+        localStorage.removeItem('debug')
+      }
+    },
+    openConnection: async (peerIdOrMultiaddr: string, options?: OpenConnectionOptions) => {
+      let peer: PeerId | Multiaddr
+
+      try {
+        peer = peerIdFromString(peerIdOrMultiaddr)
+      } catch {
+        peer = multiaddr(peerIdOrMultiaddr)
+      }
+
+      await components.connectionManager.openConnection(peer, options)
+    },
+    closeConnection: async (peerId: PeerId, options?: AbortOptions) => {
+      await Promise.all(
+        components.connectionManager.getConnections(peerId)
+          .map(async connection => {
+            try {
+              await connection.close(options)
+            } catch (err: any) {
+              connection.abort(err)
+            }
+          })
+      )
+    },
+    contentRouting: components.contentRouting,
+    peerRouting: components.peerRouting
+  }
+}

package/src/utils/debounce.ts

@@ -0,0 +1,23 @@
+export 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/utils/get-peers.ts

@@ -0,0 +1,53 @@
+import { base64 } from 'multiformats/bases/base64'
+import { toObject } from './to-object.js'
+import type { Peer } from '../rpc/index.js'
+import type { Logger, PeerStore } from '@libp2p/interface'
+import type { ConnectionManager } from '@libp2p/interface-internal'
+
+export interface Components {
+  connectionManager: ConnectionManager
+  peerStore: PeerStore
+}
+
+export async function getPeers (components: Components, log: Logger): Promise<Peer[]> {
+  const peers: Peer[] = []
+  const connections = 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 components.peerStore.get(peerId)
+
+      peers.push({
+        id: peerId,
+        addresses: peer.addresses.map(({ isCertified, multiaddr }) => {
+          return {
+            multiaddr,
+            isCertified,
+            isConnected: connectedAddresses.includes(multiaddr.toString())
+          }
+        }),
+        protocols: [...peer.protocols],
+        tags: toObject(peer.tags, (t) => t.value),
+        metadata: toObject(peer.metadata, (buf) => base64.encode(buf))
+      })
+    } catch (err) {
+      log.error('could not load peer data from peer store', err)
+
+      peers.push({
+        id: peerId,
+        addresses: conns.map(conn => {
+          return {
+            multiaddr: conn.remoteAddr,
+            isConnected: connectedAddresses.includes(conn.remoteAddr.toString())
+          }
+        }),
+        protocols: [],
+        tags: {},
+        metadata: {}
+      })
+    }
+  }
+
+  return peers
+}

package/src/utils/get-self.ts

@@ -0,0 +1,21 @@
+import { base64 } from 'multiformats/bases/base64'
+import { toObject } from './to-object.js'
+import type { Peer } from '../rpc/index.js'
+import type { PeerId, PeerStore } from '@libp2p/interface'
+
+export interface Components {
+  peerId: PeerId
+  peerStore: PeerStore
+}
+
+export async function getSelf (components: Components): Promise<Peer> {
+  const peer = await components.peerStore.get(components.peerId)
+
+  return {
+    id: peer.id,
+    addresses: peer.addresses,
+    protocols: [...peer.protocols],
+    tags: toObject(peer.tags, (t) => t.value),
+    metadata: toObject(peer.metadata, (buf) => base64.encode(buf))
+  }
+}

package/src/utils/to-object.ts

@@ -0,0 +1,9 @@
+export 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
+}