@libp2p/kad-dht 12.0.14 → 12.0.15-43046b9ae

package/src/peer-routing/index.ts

@@ -12,7 +12,7 @@ import {
 } from '../query/events.js'
 import { verifyRecord } from '../record/validators.js'
 import * as utils from '../utils.js'
-import type { KadDHTComponents, DHTRecord, DialPeerEvent, FinalPeerEvent, QueryEvent, Validators } from '../index.js'
+import type { KadDHTComponents, DHTRecord, FinalPeerEvent, QueryEvent, Validators } from '../index.js'
 import type { Message } from '../message/dht.js'
 import type { Network } from '../network.js'
 import type { QueryManager, QueryOptions } from '../query/manager.js'
@@ -195,17 +195,17 @@ export class PeerRouting {
   }
 
   /**
-   * Kademlia 'node lookup' operation on a key, which could be a the
-   * bytes from a multihash or a peer ID
+   * Kademlia 'FIND_NODE' operation on a key, which could be the bytes from
+   * a multihash or a peer ID
    */
-  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<DialPeerEvent | QueryEvent> {
+  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
     this.log('getClosestPeers to %b', key)
-    const id = await utils.convertBuffer(key)
-    const tablePeers = this.routingTable.closestPeers(id)
+    const kadId = await utils.convertBuffer(key)
+    const tablePeers = this.routingTable.closestPeers(kadId)
     const self = this // eslint-disable-line @typescript-eslint/no-this-alias
 
-    const peers = new PeerDistanceList(id, this.routingTable.kBucketSize)
-    await Promise.all(tablePeers.map(async peer => { await peers.add(peer) }))
+    const peers = new PeerDistanceList(kadId, this.routingTable.kBucketSize)
+    await Promise.all(tablePeers.map(async peer => { await peers.add({ id: peer, multiaddrs: [] }) }))
 
     const getCloserPeersQuery: QueryFunc = async function * ({ peer, signal }) {
       self.log('closerPeersSingle %s from %p', uint8ArrayToString(key, 'base32'), peer)
@@ -221,31 +221,22 @@ export class PeerRouting {
     }
 
     for await (const event of this.queryManager.run(key, getCloserPeersQuery, options)) {
-      yield event
-
       if (event.name === 'PEER_RESPONSE') {
-        await Promise.all(event.closer.map(async peerData => { await peers.add(peerData.id) }))
+        await Promise.all(event.closer.map(async peerData => {
+          await peers.add(peerData)
+        }))
       }
+
+      yield event
     }
 
     this.log('found %d peers close to %b', peers.length, key)
 
-    for (const peerId of peers.peers) {
-      try {
-        const peer = await this.peerStore.get(peerId)
-
-        yield finalPeerEvent({
-          from: this.peerId,
-          peer: {
-            id: peerId,
-            multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr)
-          }
-        }, options)
-      } catch (err: any) {
-        if (err.code !== 'ERR_NOT_FOUND') {
-          throw err
-        }
-      }
+    for (const peer of peers.peers) {
+      yield finalPeerEvent({
+        from: this.peerId,
+        peer
+      }, options)
     }
   }
 
@@ -255,7 +246,7 @@ export class PeerRouting {
    *
    * Note: The peerStore is updated with new addresses found for the given peer.
    */
-  async * getValueOrPeers (peer: PeerId, key: Uint8Array, options: RoutingOptions = {}): AsyncGenerator<DialPeerEvent | QueryEvent> {
+  async * getValueOrPeers (peer: PeerId, key: Uint8Array, options: RoutingOptions = {}): AsyncGenerator<QueryEvent> {
     for await (const event of this._getValueSingle(peer, key, options)) {
       if (event.name === 'PEER_RESPONSE') {
         if (event.record != null) {
@@ -319,7 +310,7 @@ export class PeerRouting {
     if (output.length > 0) {
       this.log('getCloserPeersOffline found %d peer(s) closer to %b than %p', output.length, key, closerThan)
     } else {
-      this.log('getCloserPeersOffline could not find peer closer to %b than %p', key, closerThan)
+      this.log('getCloserPeersOffline could not find peer closer to %b than %p with %d peers in the routing table', key, closerThan, this.routingTable.size)
     }
 
     return output

package/src/query/manager.ts

@@ -1,4 +1,4 @@
-import { TypedEventEmitter, CustomEvent, setMaxListeners } from '@libp2p/interface'
+import { setMaxListeners } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
 import { anySignal } from 'any-signal'
 import merge from 'it-merge'
@@ -13,6 +13,7 @@ import type { QueryFunc } from './types.js'
 import type { QueryEvent } from '../index.js'
 import type { RoutingTable } from '../routing-table/index.js'
 import type { ComponentLogger, Metric, Metrics, PeerId, RoutingOptions, Startable } from '@libp2p/interface'
+import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { DeferredPromise } from 'p-defer'
 
 export interface CleanUpEvents {
@@ -31,6 +32,7 @@ export interface QueryManagerComponents {
   peerId: PeerId
   metrics?: Metrics
   logger: ComponentLogger
+  connectionManager: ConnectionManager
 }
 
 export interface QueryOptions extends RoutingOptions {
@@ -53,6 +55,7 @@ export class QueryManager implements Startable {
   private queries: number
   private readonly logger: ComponentLogger
   private readonly peerId: PeerId
+  private readonly connectionManager: ConnectionManager
   private readonly routingTable: RoutingTable
   private initialQuerySelfHasRun?: DeferredPromise<void>
   private readonly logPrefix: string
@@ -73,6 +76,7 @@ export class QueryManager implements Startable {
     this.routingTable = init.routingTable
     this.logger = components.logger
     this.peerId = components.peerId
+    this.connectionManager = components.connectionManager
 
     if (components.metrics != null) {
       this.metrics = {
@@ -151,7 +155,6 @@ export class QueryManager implements Startable {
 
     // query a subset of peers up to `kBucketSize / 2` in length
     const startTime = Date.now()
-    const cleanUp = new TypedEventEmitter<CleanUpEvents>()
     let queryFinished = false
 
     try {
@@ -190,11 +193,11 @@ export class QueryManager implements Startable {
           pathIndex: index,
           numPaths: peersToQuery.length,
           alpha: this.alpha,
-          cleanUp,
           queryFuncTimeout: options.queryFuncTimeout,
           log,
           peersSeen,
-          onProgress: options.onProgress
+          onProgress: options.onProgress,
+          connectionManager: this.connectionManager
         })
       })
 
@@ -204,6 +207,17 @@ export class QueryManager implements Startable {
           log.error('query error', event.error)
         }
 
+        if (event.name === 'PEER_RESPONSE') {
+          for (const peer of [...event.closer, ...event.providers]) {
+            // eslint-disable-next-line max-depth
+            if (!(await this.connectionManager.isDialable(peer.multiaddrs))) {
+              continue
+            }
+
+            await this.routingTable.add(peer.id)
+          }
+        }
+
         yield event
       }
 
@@ -229,7 +243,6 @@ export class QueryManager implements Startable {
         stopQueryTimer()
       }
 
-      cleanUp.dispatchEvent(new CustomEvent('cleanup'))
       log('query:done in %dms', Date.now() - startTime)
     }
   }

package/src/query/query-path.ts

@@ -1,19 +1,16 @@
-import { setMaxListeners } from '@libp2p/interface'
+import { CodeError, setMaxListeners } from '@libp2p/interface'
+import { Queue } from '@libp2p/utils/queue'
 import { anySignal } from 'any-signal'
-import Queue from 'p-queue'
-import { toString } from 'uint8arrays/to-string'
-import { xor } from 'uint8arrays/xor'
+import { xor as uint8ArrayXor } from 'uint8arrays/xor'
+import { xorCompare as uint8ArrayXorCompare } from 'uint8arrays/xor-compare'
 import { convertPeerId, convertBuffer } from '../utils.js'
 import { queryErrorEvent } from './events.js'
-import { queueToGenerator } from './utils.js'
-import type { CleanUpEvents } from './manager.js'
 import type { QueryEvent } from '../index.js'
 import type { QueryFunc } from '../query/types.js'
-import type { Logger, TypedEventTarget, PeerId, RoutingOptions } from '@libp2p/interface'
+import type { Logger, PeerId, RoutingOptions, AbortOptions } from '@libp2p/interface'
+import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { PeerSet } from '@libp2p/peer-collections'
 
-const MAX_XOR = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
-
 export interface QueryPathOptions extends RoutingOptions {
   /**
    * What are we trying to find
@@ -55,11 +52,6 @@ export interface QueryPathOptions extends RoutingOptions {
    */
   numPaths: number
 
-  /**
-   * will emit a 'cleanup' event if the caller exits the for..await of early
-   */
-  cleanUp: TypedEventTarget<CleanUpEvents>
-
   /**
    * A timeout for queryFunc in ms
    */
@@ -74,6 +66,15 @@ export interface QueryPathOptions extends RoutingOptions {
    * Set of peers seen by this and other paths
    */
   peersSeen: PeerSet
+
+  /**
+   * The libp2p connection manager
+   */
+  connectionManager: ConnectionManager
+}
+
+interface QueryQueueOptions extends AbortOptions {
+  distance: Uint8Array
 }
 
 /**
@@ -81,11 +82,12 @@ export interface QueryPathOptions extends RoutingOptions {
  * every peer encountered that we have not seen before
  */
 export async function * queryPath (options: QueryPathOptions): AsyncGenerator<QueryEvent, void, undefined> {
-  const { key, startingPeer, ourPeerId, signal, query, alpha, pathIndex, numPaths, cleanUp, queryFuncTimeout, log, peersSeen } = options
+  const { key, startingPeer, ourPeerId, signal, query, alpha, pathIndex, numPaths, queryFuncTimeout, log, peersSeen, connectionManager } = options
   // Only ALPHA node/value lookups are allowed at any given time for each process
   // https://github.com/libp2p/specs/tree/master/kad-dht#alpha-concurrency-parameter-%CE%B1
-  const queue = new Queue({
-    concurrency: alpha
+  const queue = new Queue<QueryEvent | undefined, QueryQueueOptions>({
+    concurrency: alpha,
+    sort: (a, b) => uint8ArrayXorCompare(a.options.distance, b.options.distance)
   })
 
   // perform lookups on kadId, not the actual value
@@ -102,7 +104,7 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
 
     peersSeen.add(peer)
 
-    const peerXor = BigInt('0x' + toString(xor(peerKadId, kadId), 'base16'))
+    const peerXor = uint8ArrayXor(peerKadId, kadId)
 
     queue.add(async () => {
       const signals = [signal]
@@ -141,11 +143,16 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
                 continue
               }
 
+              if (!(await connectionManager.isDialable(closerPeer.multiaddrs))) { // eslint-disable-line max-depth
+                log('not querying undialable peer')
+                continue
+              }
+
               const closerPeerKadId = await convertPeerId(closerPeer.id)
-              const closerPeerXor = BigInt('0x' + toString(xor(closerPeerKadId, kadId), 'base16'))
+              const closerPeerXor = uint8ArrayXor(closerPeerKadId, kadId)
 
               // only continue query if closer peer is actually closer
-              if (closerPeerXor > peerXor) { // eslint-disable-line max-depth
+              if (uint8ArrayXorCompare(closerPeerXor, peerXor) !== -1) { // eslint-disable-line max-depth
                 log('skipping %p as they are not closer to %b than %p', closerPeer.id, key, peer)
                 continue
               }
@@ -154,7 +161,10 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
               queryPeer(closerPeer.id, closerPeerKadId)
             }
           }
-          queue.emit('completed', event)
+
+          queue.safeDispatchEvent('completed', {
+            detail: event
+          })
         }
       } catch (err: any) {
         if (!signal.aborted) {
@@ -167,13 +177,7 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
         compoundSignal.clear()
       }
     }, {
-      // use xor value as the queue priority - closer peers should execute first
-      // subtract it from MAX_XOR because higher priority values execute sooner
-
-      // @ts-expect-error this is supposed to be a Number but it's ok to use BigInts
-      // as long as all priorities are BigInts since we won't mix BigInts and Number
-      // values in arithmetic operations
-      priority: MAX_XOR - peerXor
+      distance: peerXor
     }).catch(err => {
       log.error(err)
     })
@@ -182,6 +186,18 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
   // begin the query with the starting peer
   queryPeer(startingPeer, await convertPeerId(startingPeer))
 
-  // yield results as they come in
-  yield * queueToGenerator(queue, signal, cleanUp, log)
+  try {
+    // yield results as they come in
+    for await (const event of queue.toGenerator({ signal })) {
+      if (event != null) {
+        yield event
+      }
+    }
+  } catch (err) {
+    if (signal.aborted) {
+      throw new CodeError('Query aborted', 'ERR_QUERY_ABORTED')
+    }
+
+    throw err
+  }
 }

package/src/routing-table/index.ts

@@ -4,19 +4,22 @@ import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { pbStream } from 'it-protobuf-stream'
 import { Message, MessageType } from '../message/dht.js'
 import * as utils from '../utils.js'
-import { KBucket, type PingEventDetails } from './k-bucket.js'
+import { KBucket, isLeafBucket, type Bucket, type PingEventDetails } from './k-bucket.js'
 import type { ComponentLogger, Logger, Metric, Metrics, PeerId, PeerStore, Startable, Stream } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 
 export const KAD_CLOSE_TAG_NAME = 'kad-close'
 export const KAD_CLOSE_TAG_VALUE = 50
 export const KBUCKET_SIZE = 20
+export const PREFIX_LENGTH = 32
 export const PING_TIMEOUT = 10000
 export const PING_CONCURRENCY = 10
 
 export interface RoutingTableInit {
   logPrefix: string
   protocol: string
+  prefixLength?: number
+  splitThreshold?: number
   kBucketSize?: number
   pingTimeout?: number
   pingConcurrency?: number
@@ -48,6 +51,8 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
   private readonly log: Logger
   private readonly components: RoutingTableComponents
+  private readonly prefixLength: number
+  private readonly splitThreshold: number
   private readonly pingTimeout: number
   private readonly pingConcurrency: number
   private running: boolean
@@ -56,26 +61,29 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
   private readonly tagValue: number
   private readonly metrics?: {
     routingTableSize: Metric
+    routingTableKadBucketTotal: Metric
+    routingTableKadBucketAverageOccupancy: Metric
+    routingTableKadBucketMaxDepth: Metric
   }
 
   constructor (components: RoutingTableComponents, init: RoutingTableInit) {
     super()
 
-    const { kBucketSize, pingTimeout, logPrefix, pingConcurrency, protocol, tagName, tagValue } = init
-
     this.components = components
-    this.log = components.logger.forComponent(`${logPrefix}:routing-table`)
-    this.kBucketSize = kBucketSize ?? KBUCKET_SIZE
-    this.pingTimeout = pingTimeout ?? PING_TIMEOUT
-    this.pingConcurrency = pingConcurrency ?? PING_CONCURRENCY
+    this.log = components.logger.forComponent(`${init.logPrefix}:routing-table`)
+    this.kBucketSize = init.kBucketSize ?? KBUCKET_SIZE
+    this.pingTimeout = init.pingTimeout ?? PING_TIMEOUT
+    this.pingConcurrency = init.pingConcurrency ?? PING_CONCURRENCY
     this.running = false
-    this.protocol = protocol
-    this.tagName = tagName ?? KAD_CLOSE_TAG_NAME
-    this.tagValue = tagValue ?? KAD_CLOSE_TAG_VALUE
+    this.protocol = init.protocol
+    this.tagName = init.tagName ?? KAD_CLOSE_TAG_NAME
+    this.tagValue = init.tagValue ?? KAD_CLOSE_TAG_VALUE
+    this.prefixLength = init.prefixLength ?? PREFIX_LENGTH
+    this.splitThreshold = init.splitThreshold ?? KBUCKET_SIZE
 
     this.pingQueue = new PeerQueue({
       concurrency: this.pingConcurrency,
-      metricName: `${logPrefix.replaceAll(':', '_')}_ping_queue`,
+      metricName: `${init.logPrefix.replaceAll(':', '_')}_ping_queue`,
       metrics: this.components.metrics
     })
     this.pingQueue.addEventListener('error', evt => {
@@ -84,7 +92,10 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
     if (this.components.metrics != null) {
       this.metrics = {
-        routingTableSize: this.components.metrics.registerMetric(`${logPrefix.replaceAll(':', '_')}_routing_table_size`)
+        routingTableSize: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_size`),
+        routingTableKadBucketTotal: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_total`),
+        routingTableKadBucketAverageOccupancy: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_average_occupancy`),
+        routingTableKadBucketMaxDepth: this.components.metrics.registerMetric(`${init.logPrefix.replaceAll(':', '_')}_routing_table_kad_bucket_max_depth`)
       }
     }
   }
@@ -97,8 +108,13 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     this.running = true
 
     const kBuck = new KBucket({
-      localNodeId: await utils.convertPeerId(this.components.peerId),
-      numberOfNodesPerKBucket: this.kBucketSize,
+      localPeer: {
+        kadId: await utils.convertPeerId(this.components.peerId),
+        peerId: this.components.peerId
+      },
+      kBucketSize: this.kBucketSize,
+      prefixLength: this.prefixLength,
+      splitThreshold: this.splitThreshold,
       numberOfNodesToPing: 1
     })
     this.kb = kBuck
@@ -110,6 +126,20 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
       })
     })
 
+    let peerStorePeers = 0
+
+    // add existing peers from the peer store to routing table
+    for (const peer of await this.components.peerStore.all()) {
+      if (peer.protocols.includes(this.protocol)) {
+        const id = await utils.convertPeerId(peer.id)
+
+        this.kb.add({ kadId: id, peerId: peer.id })
+        peerStorePeers++
+      }
+    }
+
+    this.log('added %d peer store peers to the routing table', peerStorePeers)
+
     // tag kad-close peers
     this._tagPeers(kBuck)
   }
@@ -130,7 +160,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
     const updatePeerTags = utils.debounce(() => {
       const newClosest = new PeerSet(
-        kBuck.closest(kBuck.localNodeId, KBUCKET_SIZE).map(contact => contact.peer)
+        kBuck.closest(kBuck.localPeer.kadId, KBUCKET_SIZE)
       )
       const addedPeers = newClosest.difference(kClosest)
       const removedPeers = kClosest.difference(newClosest)
@@ -165,12 +195,12 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     kBuck.addEventListener('added', (evt) => {
       updatePeerTags()
 
-      this.safeDispatchEvent('peer:add', { detail: evt.detail.peer })
+      this.safeDispatchEvent('peer:add', { detail: evt.detail.peerId })
     })
     kBuck.addEventListener('removed', (evt) => {
       updatePeerTags()
 
-      this.safeDispatchEvent('peer:remove', { detail: evt.detail.peer })
+      this.safeDispatchEvent('peer:remove', { detail: evt.detail.peerId })
     })
   }
 
@@ -197,7 +227,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
     const results = await Promise.all(
       oldContacts.map(async oldContact => {
         // if a previous ping wants us to ping this contact, re-use the result
-        const pingJob = this.pingQueue.find(oldContact.peer)
+        const pingJob = this.pingQueue.find(oldContact.peerId)
 
         if (pingJob != null) {
           return pingJob.join()
@@ -211,8 +241,8 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
               signal: AbortSignal.timeout(this.pingTimeout)
             }
 
-            this.log('pinging old contact %p', oldContact.peer)
-            const connection = await this.components.connectionManager.openConnection(oldContact.peer, options)
+            this.log('pinging old contact %p', oldContact.peerId)
+            const connection = await this.components.connectionManager.openConnection(oldContact.peerId, options)
             stream = await connection.newStream(this.protocol, options)
 
             const pb = pbStream(stream)
@@ -232,9 +262,9 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
             if (this.running && this.kb != null) {
               // only evict peers if we are still running, otherwise we evict
               // when dialing is cancelled due to shutdown in progress
-              this.log.error('could not ping peer %p', oldContact.peer, err)
-              this.log('evicting old contact after ping failed %p', oldContact.peer)
-              this.kb.remove(oldContact.id)
+              this.log.error('could not ping peer %p', oldContact.peerId, err)
+              this.log('evicting old contact after ping failed %p', oldContact.peerId)
+              this.kb.remove(oldContact.kadId)
             }
 
             stream?.abort(err)
@@ -244,7 +274,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
             this.metrics?.routingTableSize.update(this.size)
           }
         }, {
-          peerId: oldContact.peer
+          peerId: oldContact.peerId
         })
       })
     )
@@ -254,7 +284,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
       .length
 
     if (this.running && responded < oldContacts.length && this.kb != null) {
-      this.log('adding new contact %p', newContact.peer)
+      this.log('adding new contact %p', newContact.peerId)
       this.kb.add(newContact)
     }
   }
@@ -277,20 +307,14 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
    */
   async find (peer: PeerId): Promise<PeerId | undefined> {
     const key = await utils.convertPeerId(peer)
-    const closest = this.closestPeer(key)
-
-    if (closest != null && peer.equals(closest)) {
-      return closest
-    }
-
-    return undefined
+    return this.kb?.get(key)?.peerId
   }
 
   /**
-   * Retrieve the closest peers to the given key
+   * Retrieve the closest peers to the given kadId
    */
-  closestPeer (key: Uint8Array): PeerId | undefined {
-    const res = this.closestPeers(key, 1)
+  closestPeer (kadId: Uint8Array): PeerId | undefined {
+    const res = this.closestPeers(kadId, 1)
 
     if (res.length > 0) {
       return res[0]
@@ -300,33 +324,31 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
   }
 
   /**
-   * Retrieve the `count`-closest peers to the given key
+   * Retrieve the `count`-closest peers to the given kadId
    */
-  closestPeers (key: Uint8Array, count = this.kBucketSize): PeerId[] {
+  closestPeers (kadId: Uint8Array, count = this.kBucketSize): PeerId[] {
     if (this.kb == null) {
       return []
     }
 
-    const closest = this.kb.closest(key, count)
-
-    return closest.map(p => p.peer)
+    return [...this.kb.closest(kadId, count)]
   }
 
   /**
    * Add or update the routing table with the given peer
    */
-  async add (peer: PeerId): Promise<void> {
+  async add (peerId: PeerId): Promise<void> {
     if (this.kb == null) {
       throw new Error('RoutingTable is not started')
     }
 
-    const id = await utils.convertPeerId(peer)
+    const kadId = await utils.convertPeerId(peerId)
 
-    this.kb.add({ id, peer })
+    this.kb.add({ kadId, peerId })
 
-    this.log('added %p with kad id %b', peer, id)
+    this.log('added %p with kad id %b', peerId, kadId)
 
-    this.metrics?.routingTableSize.update(this.size)
+    this.updateMetrics()
   }
 
   /**
@@ -341,6 +363,38 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
 
     this.kb.remove(id)
 
-    this.metrics?.routingTableSize.update(this.size)
+    this.updateMetrics()
+  }
+
+  private updateMetrics (): void {
+    if (this.metrics == null || this.kb == null) {
+      return
+    }
+
+    let size = 0
+    let buckets = 0
+    let maxDepth = 0
+
+    function count (bucket: Bucket): void {
+      if (isLeafBucket(bucket)) {
+        if (bucket.depth > maxDepth) {
+          maxDepth = bucket.depth
+        }
+
+        buckets++
+        size += bucket.peers.length
+        return
+      }
+
+      count(bucket.left)
+      count(bucket.right)
+    }
+
+    count(this.kb.root)
+
+    this.metrics.routingTableSize.update(size)
+    this.metrics.routingTableKadBucketTotal.update(buckets)
+    this.metrics.routingTableKadBucketAverageOccupancy.update(Math.round(size / buckets))
+    this.metrics.routingTableKadBucketMaxDepth.update(maxDepth)
   }
 }