@libp2p/kad-dht 10.0.14 → 10.0.15-0b4a2ee79

package/src/network.ts

@@ -1,11 +1,5 @@
-import { CodeError } from '@libp2p/interface/errors'
 import { TypedEventEmitter, CustomEvent } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
-import { abortableDuplex } from 'abortable-iterator'
-import drain from 'it-drain'
-import first from 'it-first'
-import * as lp from 'it-length-prefixed'
-import { pipe } from 'it-pipe'
+import { pbStream } from 'it-protobuf-stream'
 import { Message } from './message/index.js'
 import {
   dialPeerEvent,
@@ -14,14 +8,11 @@ import {
   queryErrorEvent
 } from './query/events.js'
 import type { KadDHTComponents, QueryEvent, QueryOptions } from './index.js'
-import type { AbortOptions } from '@libp2p/interface'
+import type { AbortOptions, Logger } from '@libp2p/interface'
 import type { Stream } from '@libp2p/interface/connection'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { PeerInfo } from '@libp2p/interface/peer-info'
 import type { Startable } from '@libp2p/interface/startable'
-import type { Logger } from '@libp2p/logger'
-import type { Duplex, Source } from 'it-stream-types'
-import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface NetworkInit {
   protocol: string
@@ -49,7 +40,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
 
     const { protocol, lan } = init
     this.components = components
-    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:network`)
+    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:network`)
     this.running = false
     this.protocol = protocol
   }
@@ -97,7 +88,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
       const connection = await this.components.connectionManager.openConnection(to, options)
       const stream = await connection.newStream(this.protocol, options)
 
-      const response = await this._writeReadMessage(stream, msg.serialize(), options)
+      const response = await this._writeReadMessage(stream, msg, options)
 
       yield peerResponseEvent({
         from: to,
@@ -133,7 +124,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
       const connection = await this.components.connectionManager.openConnection(to, options)
       const stream = await connection.newStream(this.protocol, options)
 
-      await this._writeMessage(stream, msg.serialize(), options)
+      await this._writeMessage(stream, msg, options)
 
       yield peerResponseEvent({ from: to, messageType: msg.type }, options)
     } catch (err: any) {
@@ -148,17 +139,10 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
   /**
    * Write a message to the given stream
    */
-  async _writeMessage (stream: Duplex<AsyncGenerator<Uint8ArrayList>, Source<Uint8ArrayList | Uint8Array>>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions): Promise<void> {
-    if (options.signal != null) {
-      stream = abortableDuplex(stream, options.signal)
-    }
-
-    await pipe(
-      [msg],
-      (source) => lp.encode(source),
-      stream,
-      drain
-    )
+  async _writeMessage (stream: Stream, msg: Message, options: AbortOptions): Promise<void> {
+    const pb = pbStream(stream)
+    await pb.write(msg, Message, options)
+    await pb.unwrap().close(options)
   }
 
   /**
@@ -166,28 +150,14 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
    * If no response is received after the specified timeout
    * this will error out.
    */
-  async _writeReadMessage (stream: Duplex<AsyncGenerator<Uint8ArrayList>, Source<Uint8ArrayList | Uint8Array>>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions): Promise<Message> {
-    if (options.signal != null) {
-      stream = abortableDuplex(stream, options.signal)
-    }
+  async _writeReadMessage (stream: Stream, msg: Message, options: AbortOptions): Promise<Message> {
+    const pb = pbStream(stream)
 
-    const res = await pipe(
-      [msg],
-      (source) => lp.encode(source),
-      stream,
-      (source) => lp.decode(source),
-      async source => {
-        const buf = await first(source)
+    await pb.write(msg, Message, options)
 
-        if (buf != null) {
-          return buf
-        }
-
-        throw new CodeError('No message received', 'ERR_NO_MESSAGE_RECEIVED')
-      }
-    )
+    const message = await pb.read(Message, options)
 
-    const message = Message.deserialize(res)
+    await pb.unwrap().close(options)
 
     // tell any listeners about new peers we've seen
     message.closerPeers.forEach(peerData => {

package/src/peer-routing/index.ts

@@ -1,6 +1,5 @@
 import { keys } from '@libp2p/crypto'
 import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
 import { peerIdFromKeys } from '@libp2p/peer-id'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { Message, MESSAGE_TYPE } from '../message/index.js'
@@ -18,10 +17,10 @@ import type { Network } from '../network.js'
 import type { QueryManager, QueryOptions } from '../query/manager.js'
 import type { QueryFunc } from '../query/types.js'
 import type { RoutingTable } from '../routing-table/index.js'
-import type { AbortOptions } from '@libp2p/interface'
+import type { AbortOptions, Logger } from '@libp2p/interface'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { PeerInfo } from '@libp2p/interface/peer-info'
-import type { Logger } from '@libp2p/logger'
+import type { PeerStore } from '@libp2p/interface/src/peer-store/index.js'
 
 export interface PeerRoutingInit {
   routingTable: RoutingTable
@@ -32,22 +31,24 @@ export interface PeerRoutingInit {
 }
 
 export class PeerRouting {
-  private readonly components: KadDHTComponents
   private readonly log: Logger
   private readonly routingTable: RoutingTable
   private readonly network: Network
   private readonly validators: Validators
   private readonly queryManager: QueryManager
+  private readonly peerStore: PeerStore
+  private readonly peerId: PeerId
 
   constructor (components: KadDHTComponents, init: PeerRoutingInit) {
     const { routingTable, network, validators, queryManager, lan } = init
 
-    this.components = components
     this.routingTable = routingTable
     this.network = network
     this.validators = validators
     this.queryManager = queryManager
-    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:peer-routing`)
+    this.peerStore = components.peerStore
+    this.peerId = components.peerId
+    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:peer-routing`)
   }
 
   /**
@@ -62,7 +63,7 @@ export class PeerRouting {
       this.log('findPeerLocal found %p in routing table', peer)
 
       try {
-        peerData = await this.components.peerStore.get(p)
+        peerData = await this.peerStore.get(p)
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {
           throw err
@@ -72,7 +73,7 @@ export class PeerRouting {
 
     if (peerData == null) {
       try {
-        peerData = await this.components.peerStore.get(peer)
+        peerData = await this.peerStore.get(peer)
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {
           throw err
@@ -85,8 +86,7 @@ export class PeerRouting {
 
       return {
         id: peerData.id,
-        multiaddrs: peerData.addresses.map((address) => address.multiaddr),
-        protocols: []
+        multiaddrs: peerData.addresses.map((address) => address.multiaddr)
       }
     }
 
@@ -142,7 +142,7 @@ export class PeerRouting {
     if (pi != null) {
       this.log('found local')
       yield finalPeerEvent({
-        from: this.components.peerId,
+        from: this.peerId,
         peer: pi
       }, options)
       return
@@ -181,7 +181,7 @@ export class PeerRouting {
     }
 
     if (!foundPeer) {
-      yield queryErrorEvent({ from: this.components.peerId, error: new CodeError('Not found', 'ERR_NOT_FOUND') }, options)
+      yield queryErrorEvent({ from: this.peerId, error: new CodeError('Not found', 'ERR_NOT_FOUND') }, options)
     }
   }
 
@@ -220,14 +220,13 @@ export class PeerRouting {
 
     for (const peerId of peers.peers) {
       try {
-        const peer = await this.components.peerStore.get(peerId)
+        const peer = await this.peerStore.get(peerId)
 
         yield finalPeerEvent({
-          from: this.components.peerId,
+          from: this.peerId,
           peer: {
             id: peerId,
-            multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr),
-            protocols: peer.protocols
+            multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr)
           }
         }, options)
       } catch (err: any) {
@@ -292,12 +291,11 @@ export class PeerRouting {
       }
 
       try {
-        const peer = await this.components.peerStore.get(peerId)
+        const peer = await this.peerStore.get(peerId)
 
         output.push({
           id: peerId,
-          multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr),
-          protocols: peer.protocols
+          multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr)
         })
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {

package/src/providers.ts

@@ -1,4 +1,3 @@
-import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
 import cache from 'hashlru'
 import { Key } from 'interface-datastore/key'
@@ -11,13 +10,12 @@ import {
   PROVIDERS_LRU_CACHE_SIZE,
   PROVIDER_KEY_PREFIX
 } from './constants.js'
+import type { ComponentLogger, Logger } from '@libp2p/interface'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Startable } from '@libp2p/interface/startable'
 import type { Datastore } from 'interface-datastore'
 import type { CID } from 'multiformats'
 
-const log = logger('libp2p:kad-dht:providers')
-
 export interface ProvidersInit {
   cacheSize?: number
   /**
@@ -32,6 +30,7 @@ export interface ProvidersInit {
 
 export interface ProvidersComponents {
   datastore: Datastore
+  logger: ComponentLogger
 }
 
 /**
@@ -47,7 +46,8 @@ export interface ProvidersComponents {
  * access is fast there is an LRU cache in front of that.
  */
 export class Providers implements Startable {
-  private readonly components: ProvidersComponents
+  private readonly log: Logger
+  private readonly datastore: Datastore
   private readonly cache: ReturnType<typeof cache>
   private readonly cleanupInterval: number
   private readonly provideValidity: number
@@ -58,7 +58,8 @@ export class Providers implements Startable {
   constructor (components: ProvidersComponents, init: ProvidersInit = {}) {
     const { cacheSize, cleanupInterval, provideValidity } = init
 
-    this.components = components
+    this.log = components.logger.forComponent('libp2p:kad-dht:providers')
+    this.datastore = components.datastore
     this.cleanupInterval = cleanupInterval ?? PROVIDERS_CLEANUP_INTERVAL
     this.provideValidity = provideValidity ?? PROVIDERS_VALIDITY
     this.cache = cache(cacheSize ?? PROVIDERS_LRU_CACHE_SIZE)
@@ -83,7 +84,7 @@ export class Providers implements Startable {
     this.cleaner = setInterval(
       () => {
         this._cleanup().catch(err => {
-          log.error(err)
+          this.log.error(err)
         })
       },
       this.cleanupInterval
@@ -112,10 +113,10 @@ export class Providers implements Startable {
       let count = 0
       let deleteCount = 0
       const deleted = new Map<string, Set<string>>()
-      const batch = this.components.datastore.batch()
+      const batch = this.datastore.batch()
 
       // Get all provider entries from the datastore
-      const query = this.components.datastore.query({ prefix: PROVIDER_KEY_PREFIX })
+      const query = this.datastore.query({ prefix: PROVIDER_KEY_PREFIX })
 
       for await (const entry of query) {
         try {
@@ -126,7 +127,7 @@ export class Providers implements Startable {
           const delta = now - time
           const expired = delta > this.provideValidity
 
-          log('comparing: %d - %d = %d > %d %s', now, time, delta, this.provideValidity, expired ? '(expired)' : '')
+          this.log('comparing: %d - %d = %d > %d %s', now, time, delta, this.provideValidity, expired ? '(expired)' : '')
 
           if (expired) {
             deleteCount++
@@ -137,16 +138,16 @@ export class Providers implements Startable {
           }
           count++
         } catch (err: any) {
-          log.error(err.message)
+          this.log.error(err.message)
         }
       }
 
       // Commit the deletes to the datastore
       if (deleted.size > 0) {
-        log('deleting %d / %d entries', deleteCount, count)
+        this.log('deleting %d / %d entries', deleteCount, count)
         await batch.commit()
       } else {
-        log('nothing to delete')
+        this.log('nothing to delete')
       }
 
       // Clear expired entries from the cache
@@ -167,7 +168,7 @@ export class Providers implements Startable {
         }
       }
 
-      log('Cleanup successful (%dms)', Date.now() - start)
+      this.log('Cleanup successful (%dms)', Date.now() - start)
     })
   }
 
@@ -179,7 +180,7 @@ export class Providers implements Startable {
     let provs: Map<string, Date> = this.cache.get(cacheKey)
 
     if (provs == null) {
-      provs = await loadProviders(this.components.datastore, cid)
+      provs = await loadProviders(this.datastore, cid)
       this.cache.set(cacheKey, provs)
     }
 
@@ -191,17 +192,17 @@ export class Providers implements Startable {
    */
   async addProvider (cid: CID, provider: PeerId): Promise<void> {
     await this.syncQueue.add(async () => {
-      log('%p provides %s', provider, cid)
+      this.log('%p provides %s', provider, cid)
       const provs = await this._getProvidersMap(cid)
 
-      log('loaded %s provs', provs.size)
+      this.log('loaded %s provs', provs.size)
       const now = new Date()
       provs.set(provider.toString(), now)
 
       const dsKey = makeProviderKey(cid)
       this.cache.set(dsKey, provs)
 
-      await writeProviderEntry(this.components.datastore, cid, provider, now)
+      await writeProviderEntry(this.datastore, cid, provider, now)
     })
   }
 
@@ -210,7 +211,7 @@ export class Providers implements Startable {
    */
   async getProviders (cid: CID): Promise<PeerId[]> {
     return this.syncQueue.add(async () => {
-      log('get providers for %s', cid)
+      this.log('get providers for %s', cid)
       const provs = await this._getProvidersMap(cid)
 
       return [...provs.keys()].map(peerIdStr => {

package/src/query/manager.ts

@@ -1,6 +1,5 @@
 import { AbortError } from '@libp2p/interface/errors'
 import { TypedEventEmitter, CustomEvent, setMaxListeners } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { anySignal } from 'any-signal'
 import merge from 'it-merge'
@@ -13,6 +12,7 @@ import { queryPath } from './query-path.js'
 import type { QueryFunc } from './types.js'
 import type { QueryEvent, QueryOptions as RootQueryOptions } from '../index.js'
 import type { RoutingTable } from '../routing-table/index.js'
+import type { ComponentLogger } from '@libp2p/interface'
 import type { Metric, Metrics } from '@libp2p/interface/metrics'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Startable } from '@libp2p/interface/startable'
@@ -33,6 +33,7 @@ export interface QueryManagerInit {
 export interface QueryManagerComponents {
   peerId: PeerId
   metrics?: Metrics
+  logger: ComponentLogger
 }
 
 export interface QueryOptions extends RootQueryOptions {
@@ -44,25 +45,24 @@ export interface QueryOptions extends RootQueryOptions {
  * Keeps track of all running queries
  */
 export class QueryManager implements Startable {
-  private readonly components: QueryManagerComponents
   private readonly lan: boolean
   public disjointPaths: number
   private readonly alpha: number
   private readonly shutDownController: AbortController
   private running: boolean
   private queries: number
-  private metrics?: {
+  private readonly logger: ComponentLogger
+  private readonly peerId: PeerId
+  private readonly routingTable: RoutingTable
+  private initialQuerySelfHasRun?: DeferredPromise<void>
+  private readonly metrics?: {
     runningQueries: Metric
     queryTime: Metric
   }
 
-  private readonly routingTable: RoutingTable
-  private initialQuerySelfHasRun?: DeferredPromise<void>
-
   constructor (components: QueryManagerComponents, init: QueryManagerInit) {
     const { lan = false, disjointPaths = K, alpha = ALPHA } = init
 
-    this.components = components
     this.disjointPaths = disjointPaths ?? K
     this.running = false
     this.alpha = alpha ?? ALPHA
@@ -70,6 +70,15 @@ export class QueryManager implements Startable {
     this.queries = 0
     this.initialQuerySelfHasRun = init.initialQuerySelfHasRun
     this.routingTable = init.routingTable
+    this.logger = components.logger
+    this.peerId = components.peerId
+
+    if (components.metrics != null) {
+      this.metrics = {
+        runningQueries: components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_running_queries`),
+        queryTime: components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_query_time_seconds`)
+      }
+    }
 
     // allow us to stop queries on shut down
     this.shutDownController = new AbortController()
@@ -86,13 +95,6 @@ export class QueryManager implements Startable {
    */
   async start (): Promise<void> {
     this.running = true
-
-    if (this.components.metrics != null && this.metrics == null) {
-      this.metrics = {
-        runningQueries: this.components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_running_queries`),
-        queryTime: this.components.metrics.registerMetric(`libp2p_kad_dht_${this.lan ? 'lan' : 'wan'}_query_time_seconds`)
-      }
-    }
   }
 
   /**
@@ -131,7 +133,7 @@ export class QueryManager implements Startable {
     // so make sure we don't make a lot of noise in the logs
     setMaxListeners(Infinity, signal)
 
-    const log = logger(`libp2p:kad-dht:${this.lan ? 'lan' : 'wan'}:query:` + uint8ArrayToString(key, 'base58btc'))
+    const log = this.logger.forComponent(`libp2p:kad-dht:${this.lan ? 'lan' : 'wan'}:query:` + uint8ArrayToString(key, 'base58btc'))
 
     // query a subset of peers up to `kBucketSize / 2` in length
     const startTime = Date.now()
@@ -174,7 +176,7 @@ export class QueryManager implements Startable {
         return queryPath({
           key,
           startingPeer: peer,
-          ourPeerId: this.components.peerId,
+          ourPeerId: this.peerId,
           signal,
           query: queryFunc,
           pathIndex: index,

package/src/query/query-path.ts

@@ -1,17 +1,16 @@
-import { CodeError } from '@libp2p/interface/errors'
 import { anySignal } from 'any-signal'
-import defer from 'p-defer'
 import Queue from 'p-queue'
 import { toString } from 'uint8arrays/to-string'
 import { xor } from 'uint8arrays/xor'
 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, QueryOptions } from '../index.js'
 import type { QueryFunc } from '../query/types.js'
+import type { Logger } from '@libp2p/interface'
 import type { TypedEventTarget } from '@libp2p/interface/events'
 import type { PeerId } from '@libp2p/interface/peer-id'
-import type { Logger } from '@libp2p/logger'
 import type { PeerSet } from '@libp2p/peer-collections'
 
 const MAX_XOR = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
@@ -182,73 +181,5 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
   queryPeer(startingPeer, await convertPeerId(startingPeer))
 
   // yield results as they come in
-  yield * toGenerator(queue, signal, cleanUp, log)
-}
-
-async function * toGenerator (queue: Queue, signal: AbortSignal, cleanUp: TypedEventTarget<CleanUpEvents>, log: Logger): AsyncGenerator<QueryEvent, void, undefined> {
-  let deferred = defer()
-  let running = true
-  const results: QueryEvent[] = []
-
-  const cleanup = (): void => {
-    if (!running) {
-      return
-    }
-
-    log('clean up queue, results %d, queue size %d, pending tasks %d', results.length, queue.size, queue.pending)
-
-    running = false
-    queue.clear()
-    results.splice(0, results.length)
-  }
-
-  queue.on('completed', result => {
-    results.push(result)
-    deferred.resolve()
-  })
-  queue.on('error', err => {
-    log('queue error', err)
-    cleanup()
-    deferred.reject(err)
-  })
-  queue.on('idle', () => {
-    log('queue idle')
-    running = false
-    deferred.resolve()
-  })
-
-  // clear the queue and throw if the query is aborted
-  signal.addEventListener('abort', () => {
-    log('abort queue')
-    const wasRunning = running
-    cleanup()
-
-    if (wasRunning) {
-      deferred.reject(new CodeError('Query aborted', 'ERR_QUERY_ABORTED'))
-    }
-  })
-
-  // the user broke out of the loop early, ensure we resolve the deferred result
-  // promise and clear the queue of any remaining jobs
-  cleanUp.addEventListener('cleanup', () => {
-    cleanup()
-    deferred.resolve()
-  })
-
-  while (running) { // eslint-disable-line no-unmodified-loop-condition
-    await deferred.promise
-    deferred = defer()
-
-    // yield all available results
-    while (results.length > 0) {
-      const result = results.shift()
-
-      if (result != null) {
-        yield result
-      }
-    }
-  }
-
-  // yield any remaining results
-  yield * results
+  yield * queueToGenerator(queue, signal, cleanUp, log)
 }

package/src/query/utils.ts

@@ -0,0 +1,65 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { pushable } from 'it-pushable'
+import type { CleanUpEvents } from './manager.js'
+import type { QueryEvent } from '../index.js'
+import type { Logger } from '@libp2p/interface'
+import type { TypedEventTarget } from '@libp2p/interface/events'
+import type Queue from 'p-queue'
+
+export async function * queueToGenerator (queue: Queue, signal: AbortSignal, cleanUp: TypedEventTarget<CleanUpEvents>, log: Logger): AsyncGenerator<QueryEvent, void, undefined> {
+  const stream = pushable<QueryEvent>({
+    objectMode: true
+  })
+
+  const cleanup = (err?: Error): void => {
+    log('clean up queue, results %d, queue size %d, pending tasks %d', stream.readableLength, queue.size, queue.pending)
+    queue.clear()
+    stream.end(err)
+  }
+
+  const onQueueJobComplete = (result: QueryEvent): void => {
+    if (result != null) {
+      stream.push(result)
+    }
+  }
+
+  const onQueueError = (err: Error): void => {
+    log('queue error', err)
+    cleanup(err)
+  }
+
+  const onQueueIdle = (): void => {
+    log('queue idle')
+    cleanup()
+  }
+
+  // clear the queue and throw if the query is aborted
+  const onSignalAbort = (): void => {
+    log('abort queue')
+    cleanup(new CodeError('Query aborted', 'ERR_QUERY_ABORTED'))
+  }
+
+  // the user broke out of the loop early, ensure we resolve the deferred result
+  // promise and clear the queue of any remaining jobs
+  const onCleanUp = (): void => {
+    cleanup()
+  }
+
+  // add listeners
+  queue.on('completed', onQueueJobComplete)
+  queue.on('error', onQueueError)
+  queue.on('idle', onQueueIdle)
+  signal.addEventListener('abort', onSignalAbort)
+  cleanUp.addEventListener('cleanup', onCleanUp)
+
+  try {
+    yield * stream
+  } finally {
+    // remove listeners
+    queue.removeListener('completed', onQueueJobComplete)
+    queue.removeListener('error', onQueueError)
+    queue.removeListener('idle', onQueueIdle)
+    signal.removeEventListener('abort', onSignalAbort)
+    cleanUp.removeEventListener('cleanup', onCleanUp)
+  }
+}

package/src/query-self.ts

@@ -1,5 +1,4 @@
 import { setMaxListeners } from '@libp2p/interface/events'
-import { logger, type Logger } from '@libp2p/logger'
 import { anySignal } from 'any-signal'
 import length from 'it-length'
 import { pipe } from 'it-pipe'
@@ -9,6 +8,7 @@ import { pEvent } from 'p-event'
 import { QUERY_SELF_INTERVAL, QUERY_SELF_TIMEOUT, K, QUERY_SELF_INITIAL_INTERVAL } from './constants.js'
 import type { PeerRouting } from './peer-routing/index.js'
 import type { RoutingTable } from './routing-table/index.js'
+import type { ComponentLogger, Logger } from '@libp2p/interface'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Startable } from '@libp2p/interface/startable'
 import type { DeferredPromise } from 'p-defer'
@@ -26,6 +26,7 @@ export interface QuerySelfInit {
 
 export interface QuerySelfComponents {
   peerId: PeerId
+  logger: ComponentLogger
 }
 
 /**
@@ -33,7 +34,7 @@ export interface QuerySelfComponents {
  */
 export class QuerySelf implements Startable {
   private readonly log: Logger
-  private readonly components: QuerySelfComponents
+  private readonly peerId: PeerId
   private readonly peerRouting: PeerRouting
   private readonly routingTable: RoutingTable
   private readonly count: number
@@ -49,8 +50,8 @@ export class QuerySelf implements Startable {
   constructor (components: QuerySelfComponents, init: QuerySelfInit) {
     const { peerRouting, lan, count, interval, queryTimeout, routingTable } = init
 
-    this.components = components
-    this.log = logger(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:query-self`)
+    this.peerId = components.peerId
+    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:query-self`)
     this.started = false
     this.peerRouting = peerRouting
     this.routingTable = routingTable
@@ -125,7 +126,7 @@ export class QuerySelf implements Startable {
         const start = Date.now()
 
         const found = await pipe(
-          this.peerRouting.getClosestPeers(this.components.peerId.toBytes(), {
+          this.peerRouting.getClosestPeers(this.peerId.toBytes(), {
             signal,
             isSelfQuery: true
           }),