libp2p 0.46.19 → 0.46.20

package/src/connection-manager/utils.ts

@@ -1,14 +1,12 @@
 import { setMaxListeners } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
 import { type AbortOptions, multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { type ClearableSignal, anySignal } from 'any-signal'
-
-const log = logger('libp2p:connection-manager:utils')
+import type { LoggerOptions } from '@libp2p/interface'
 
 /**
  * Resolve multiaddr recursively
  */
-export async function resolveMultiaddrs (ma: Multiaddr, options: AbortOptions): Promise<Multiaddr[]> {
+export async function resolveMultiaddrs (ma: Multiaddr, options: AbortOptions & LoggerOptions): Promise<Multiaddr[]> {
   // TODO: recursive logic should live in multiaddr once dns4/dns6 support is in place
   // Now only supporting resolve for dnsaddr
   const resolvableProto = ma.protoNames().includes('dnsaddr')
@@ -31,7 +29,7 @@ export async function resolveMultiaddrs (ma: Multiaddr, options: AbortOptions):
     return array
   }, ([]))
 
-  log('resolved %s to', ma, output.map(ma => ma.toString()))
+  options.log('resolved %s to', ma, output.map(ma => ma.toString()))
 
   return output
 }
@@ -39,13 +37,13 @@ export async function resolveMultiaddrs (ma: Multiaddr, options: AbortOptions):
 /**
  * Resolve a given multiaddr. If this fails, an empty array will be returned
  */
-async function resolveRecord (ma: Multiaddr, options: AbortOptions): Promise<Multiaddr[]> {
+async function resolveRecord (ma: Multiaddr, options: AbortOptions & LoggerOptions): Promise<Multiaddr[]> {
   try {
     ma = multiaddr(ma.toString()) // Use current multiaddr module
     const multiaddrs = await ma.resolve(options)
     return multiaddrs
   } catch (err) {
-    log.error(`multiaddr ${ma.toString()} could not be resolved`, err)
+    options.log.error(`multiaddr ${ma.toString()} could not be resolved`, err)
     return []
   }
 }

package/src/identify/identify.ts

@@ -1,6 +1,5 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { setMaxListeners } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
 import { peerIdFromKeys } from '@libp2p/peer-id'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 import { type Multiaddr, multiaddr, protocols } from '@multiformats/multiaddr'
@@ -20,7 +19,7 @@ import {
 } from './consts.js'
 import { Identify } from './pb/message.js'
 import type { IdentifyService, IdentifyServiceComponents, IdentifyServiceInit } from './index.js'
-import type { Libp2pEvents, IdentifyResult, SignedPeerRecord, AbortOptions } from '@libp2p/interface'
+import type { Libp2pEvents, IdentifyResult, SignedPeerRecord, AbortOptions, Logger } from '@libp2p/interface'
 import type { Connection, Stream } from '@libp2p/interface/connection'
 import type { TypedEventTarget } from '@libp2p/interface/events'
 import type { PeerId } from '@libp2p/interface/peer-id'
@@ -30,8 +29,6 @@ import type { AddressManager } from '@libp2p/interface-internal/address-manager'
 import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
 
-const log = logger('libp2p:identify')
-
 // https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L52
 const MAX_IDENTIFY_MESSAGE_SIZE = 1024 * 8
 
@@ -73,6 +70,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
   private readonly maxObservedAddresses: number
   private readonly events: TypedEventTarget<Libp2pEvents>
   private readonly runOnTransientConnection: boolean
+  readonly #log: Logger
 
   constructor (components: IdentifyServiceComponents, init: IdentifyServiceInit) {
     this.started = false
@@ -82,6 +80,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
     this.addressManager = components.addressManager
     this.connectionManager = components.connectionManager
     this.events = components.events
+    this.#log = components.logger.forComponent('libp2p:identify')
 
     this.identifyProtocolStr = `/${init.protocolPrefix ?? defaultValues.protocolPrefix}/${MULTICODEC_IDENTIFY_PROTOCOL_NAME}/${MULTICODEC_IDENTIFY_PROTOCOL_VERSION}`
     this.identifyPushProtocolStr = `/${init.protocolPrefix ?? defaultValues.protocolPrefix}/${MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME}/${MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION}`
@@ -104,13 +103,13 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
       // When a new connection happens, trigger identify
       components.events.addEventListener('connection:open', (evt) => {
         const connection = evt.detail
-        this.identify(connection).catch(err => { log.error('error during identify trigged by connection:open', err) })
+        this.identify(connection).catch(err => { this.#log.error('error during identify trigged by connection:open', err) })
       })
     }
 
     // When self peer record changes, trigger identify-push
     components.events.addEventListener('self:peer:update', (evt) => {
-      void this.push().catch(err => { log.error(err) })
+      void this.push().catch(err => { this.#log.error(err) })
     })
 
     // Append user agent version to default AGENT_VERSION depending on the environment
@@ -141,7 +140,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
 
     await this.registrar.handle(this.identifyProtocolStr, (data) => {
       void this._handleIdentify(data).catch(err => {
-        log.error(err)
+        this.#log.error(err)
       })
     }, {
       maxInboundStreams: this.maxInboundStreams,
@@ -150,7 +149,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
     })
     await this.registrar.handle(this.identifyPushProtocolStr, (data) => {
       void this._handlePush(data).catch(err => {
-        log.error(err)
+        this.#log.error(err)
       })
     }, {
       maxInboundStreams: this.maxPushIncomingStreams,
@@ -215,7 +214,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
         })
       } catch (err: any) {
         // Just log errors
-        log.error('could not push identify update to peer', err)
+        this.#log.error('could not push identify update to peer', err)
         stream?.abort(err)
       }
     })
@@ -258,7 +257,15 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
   async _identify (connection: Connection, options: AbortOptions = {}): Promise<Identify> {
     let stream: Stream | undefined
 
-    options.signal = options.signal ?? AbortSignal.timeout(this.timeout)
+    if (options.signal == null) {
+      const signal = AbortSignal.timeout(this.timeout)
+      setMaxListeners(Infinity, signal)
+
+      options = {
+        ...options,
+        signal
+      }
+    }
 
     try {
       stream = await connection.newStream([this.identifyProtocolStr], {
@@ -276,7 +283,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
 
       return message
     } catch (err: any) {
-      log.error('error while reading identify message', err)
+      this.#log.error('error while reading identify message', err)
       stream?.abort(err)
       throw err
     }
@@ -307,12 +314,12 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
     // Get the observedAddr if there is one
     const cleanObservedAddr = getCleanMultiaddr(observedAddr)
 
-    log('identify completed for peer %p and protocols %o', id, protocols)
-    log('our observed address is %a', cleanObservedAddr)
+    this.#log('identify completed for peer %p and protocols %o', id, protocols)
+    this.#log('our observed address is %a', cleanObservedAddr)
 
     if (cleanObservedAddr != null &&
         this.addressManager.getObservedAddrs().length < (this.maxObservedAddresses ?? Infinity)) {
-      log('storing our observed address %a', cleanObservedAddr)
+      this.#log('storing our observed address %a', cleanObservedAddr)
       this.addressManager.addObservedAddr(cleanObservedAddr)
     }
 
@@ -370,7 +377,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
         signal
       })
     } catch (err: any) {
-      log.error('could not respond to identify request', err)
+      this.#log.error('could not respond to identify request', err)
       stream.abort(err)
     }
   }
@@ -399,16 +406,16 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
 
       await this.#consumeIdentifyMessage(connection, message)
     } catch (err: any) {
-      log.error('received invalid message', err)
+      this.#log.error('received invalid message', err)
       stream.abort(err)
       return
     }
 
-    log('handled push from %p', connection.remotePeer)
+    this.#log('handled push from %p', connection.remotePeer)
   }
 
   async #consumeIdentifyMessage (connection: Connection, message: Identify): Promise<IdentifyResult> {
-    log('received identify from %p', connection.remotePeer)
+    this.#log('received identify from %p', connection.remotePeer)
 
     if (message == null) {
       throw new CodeError('message was null or undefined', 'ERR_INVALID_MESSAGE')
@@ -441,7 +448,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
 
     // if the peer record has been sent, prefer the addresses in the record as they are signed by the remote peer
     if (message.signedPeerRecord != null) {
-      log('received signedPeerRecord in push from %p', connection.remotePeer)
+      this.#log('received signedPeerRecord in push from %p', connection.remotePeer)
 
       let peerRecordEnvelope = message.signedPeerRecord
       const envelope = await RecordEnvelope.openAndCertify(peerRecordEnvelope, PeerRecord.DOMAIN)
@@ -478,7 +485,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
 
           // ensure seq is greater than, or equal to, the last received
           if (storedRecord.seqNumber >= peerRecord.seqNumber) {
-            log('sequence number was lower or equal to existing sequence number - stored: %d received: %d', storedRecord.seqNumber, peerRecord.seqNumber)
+            this.#log('sequence number was lower or equal to existing sequence number - stored: %d received: %d', storedRecord.seqNumber, peerRecord.seqNumber)
             peerRecord = storedRecord
             peerRecordEnvelope = existingPeer.peerRecordEnvelope
           }
@@ -499,10 +506,10 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
         addresses: peerRecord.multiaddrs
       }
     } else {
-      log('%p did not send a signed peer record', connection.remotePeer)
+      this.#log('%p did not send a signed peer record', connection.remotePeer)
     }
 
-    log('patching %p with', connection.remotePeer, peer)
+    this.#log('patching %p with', connection.remotePeer, peer)
     await this.peerStore.patch(connection.remotePeer, peer)
 
     if (message.agentVersion != null || message.protocolVersion != null) {
@@ -516,7 +523,7 @@ export class DefaultIdentifyService implements Startable, IdentifyService {
         metadata.ProtocolVersion = uint8ArrayFromString(message.protocolVersion)
       }
 
-      log('merging %p metadata', connection.remotePeer, metadata)
+      this.#log('merging %p metadata', connection.remotePeer, metadata)
       await this.peerStore.merge(connection.remotePeer, {
         metadata
       })

package/src/identify/index.ts

@@ -4,7 +4,7 @@ import {
 } from './consts.js'
 import { DefaultIdentifyService } from './identify.js'
 import { Identify } from './pb/message.js'
-import type { AbortOptions, IdentifyResult, Libp2pEvents } from '@libp2p/interface'
+import type { AbortOptions, IdentifyResult, Libp2pEvents, ComponentLogger } from '@libp2p/interface'
 import type { TypedEventTarget } from '@libp2p/interface/events'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { PeerStore } from '@libp2p/interface/peer-store'
@@ -59,6 +59,7 @@ export interface IdentifyServiceComponents {
   registrar: Registrar
   addressManager: AddressManager
   events: TypedEventTarget<Libp2pEvents>
+  logger: ComponentLogger
 }
 
 /**

package/src/index.ts

@@ -19,7 +19,7 @@ import type { AddressManagerInit } from './address-manager/index.js'
 import type { Components } from './components.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { TransportManagerInit } from './transport-manager.js'
-import type { Libp2p, ServiceMap, RecursivePartial } from '@libp2p/interface'
+import type { Libp2p, ServiceMap, RecursivePartial, ComponentLogger } from '@libp2p/interface'
 import type { ConnectionProtector } from '@libp2p/interface/connection'
 import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter'
 import type { ConnectionGater } from '@libp2p/interface/connection-gater'
@@ -108,6 +108,27 @@ export interface Libp2pInit<T extends ServiceMap = { x: Record<string, unknown>
    * Arbitrary libp2p modules
    */
   services: ServiceFactoryMap<T>
+
+  /**
+   * An optional logging implementation that can be used to write runtime logs.
+   *
+   * Set the `DEBUG` env var or the `debug` key on LocalStorage to see logs.
+   *
+   * @example
+   *
+   * Node.js:
+   *
+   * ```console
+   * $ DEBUG="*libp2p:*" node myscript.js
+   * ```
+   *
+   * Browsers:
+   *
+   * ```javascript
+   * localStorage.setItem('debug', '*libp2p:*')
+   * ```
+   */
+  logger?: ComponentLogger
 }
 
 export type { Libp2p }

package/src/libp2p.ts

@@ -5,7 +5,7 @@ import { TypedEventEmitter, CustomEvent, setMaxListeners } from '@libp2p/interfa
 import { peerDiscovery } from '@libp2p/interface/peer-discovery'
 import { type PeerRouting, peerRouting } from '@libp2p/interface/peer-routing'
 import { DefaultKeyChain } from '@libp2p/keychain'
-import { logger } from '@libp2p/logger'
+import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
@@ -28,7 +28,7 @@ import { DefaultTransportManager } from './transport-manager.js'
 import { DefaultUpgrader } from './upgrader.js'
 import type { Components } from './components.js'
 import type { Libp2p, Libp2pInit, Libp2pOptions } from './index.js'
-import type { Libp2pEvents, PendingDial, ServiceMap, AbortOptions } from '@libp2p/interface'
+import type { Libp2pEvents, PendingDial, ServiceMap, AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
 import type { Connection, NewStreamOptions, Stream } from '@libp2p/interface/connection'
 import type { KeyChain } from '@libp2p/interface/keychain'
 import type { Metrics } from '@libp2p/interface/metrics'
@@ -39,8 +39,6 @@ import type { Topology } from '@libp2p/interface/topology'
 import type { StreamHandler, StreamHandlerOptions } from '@libp2p/interface-internal/registrar'
 import type { Datastore } from 'interface-datastore'
 
-const log = logger('libp2p')
-
 export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends TypedEventEmitter<Libp2pEvents> implements Libp2p<T> {
   public peerId: PeerId
   public peerStore: PeerStore
@@ -49,9 +47,11 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
   public keychain: KeyChain
   public metrics?: Metrics
   public services: T
+  public logger: ComponentLogger
 
   public components: Components
   #started: boolean
+  readonly #log: Logger
 
   constructor (init: Libp2pInit<T>) {
     super()
@@ -74,10 +74,13 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
 
     this.#started = false
     this.peerId = init.peerId
+    this.logger = init.logger ?? defaultLogger()
+    this.#log = this.logger.forComponent('libp2p')
     // @ts-expect-error {} may not be of type T
     this.services = {}
     const components = this.components = defaultComponents({
       peerId: init.peerId,
+      logger: this.logger,
       events,
       datastore: init.datastore ?? new MemoryDatastore(),
       connectionGater: connectionGater(init.connectionGater)
@@ -170,7 +173,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
         const service: any = createService(this.components)
 
         if (service == null) {
-          log.error('service factory %s returned null or undefined instance', name)
+          this.#log.error('service factory %s returned null or undefined instance', name)
           continue
         }
 
@@ -178,17 +181,17 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
         this.configureComponent(name, service)
 
         if (service[contentRouting] != null) {
-          log('registering service %s for content routing', name)
+          this.#log('registering service %s for content routing', name)
           contentRouters.push(service[contentRouting])
         }
 
         if (service[peerRouting] != null) {
-          log('registering service %s for peer routing', name)
+          this.#log('registering service %s for peer routing', name)
           peerRouters.push(service[peerRouting])
         }
 
         if (service[peerDiscovery] != null) {
-          log('registering service %s for peer discovery', name)
+          this.#log('registering service %s for peer discovery', name)
           service[peerDiscovery].addEventListener('peer', (evt: CustomEvent<PeerInfo>) => {
             this.#onDiscoveryPeer(evt)
           })
@@ -199,7 +202,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
 
   private configureComponent <T> (name: string, component: T): T {
     if (component == null) {
-      log.error('component %s was null or undefined', name)
+      this.#log.error('component %s was null or undefined', name)
     }
 
     this.components[name] = component
@@ -217,12 +220,12 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
 
     this.#started = true
 
-    log('libp2p is starting')
+    this.#log('libp2p is starting')
 
     const keys = await this.keychain.listKeys()
 
     if (keys.find(key => key.name === 'self') == null) {
-      log('importing self key into keychain')
+      this.#log('importing self key into keychain')
       await this.keychain.importPeer('self', this.components.peerId)
     }
 
@@ -232,9 +235,9 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
       await this.components.afterStart?.()
 
       this.safeDispatchEvent('start', { detail: this })
-      log('libp2p has started')
+      this.#log('libp2p has started')
     } catch (err: any) {
-      log.error('An error occurred starting libp2p', err)
+      this.#log.error('An error occurred starting libp2p', err)
       await this.stop()
       throw err
     }
@@ -248,7 +251,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
       return
     }
 
-    log('libp2p is stopping')
+    this.#log('libp2p is stopping')
 
     this.#started = false
 
@@ -257,7 +260,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
     await this.components.afterStop?.()
 
     this.safeDispatchEvent('stop', { detail: this })
-    log('libp2p has stopped')
+    this.#log('libp2p has stopped')
   }
 
   isStarted (): boolean {
@@ -322,7 +325,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
    * Get the public key for the given peer id
    */
   async getPublicKey (peer: PeerId, options: AbortOptions = {}): Promise<Uint8Array> {
-    log('getPublicKey %p', peer)
+    this.#log('getPublicKey %p', peer)
 
     if (peer.publicKey != null) {
       return peer.publicKey
@@ -391,7 +394,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
     const { detail: peer } = evt
 
     if (peer.id.toString() === this.peerId.toString()) {
-      log.error(new Error(codes.ERR_DISCOVERED_SELF))
+      this.#log.error(new Error(codes.ERR_DISCOVERED_SELF))
       return
     }
 
@@ -399,7 +402,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
       multiaddrs: peer.multiaddrs,
       protocols: peer.protocols
     })
-      .catch(err => { log.error(err) })
+      .catch(err => { this.#log.error(err) })
   }
 }
 

package/src/ping/index.ts

@@ -109,7 +109,14 @@ class DefaultPingService implements Startable, PingService {
     let stream: Stream | undefined
     let onAbort = (): void => {}
 
-    options.signal = options.signal ?? AbortSignal.timeout(this.timeout)
+    if (options.signal == null) {
+      const signal = AbortSignal.timeout(this.timeout)
+
+      options = {
+        ...options,
+        signal
+      }
+    }
 
     try {
       stream = await connection.newStream(this.protocol, {
@@ -122,7 +129,7 @@ class DefaultPingService implements Startable, PingService {
       }
 
       // make stream abortable
-      options.signal.addEventListener('abort', onAbort, { once: true })
+      options.signal?.addEventListener('abort', onAbort, { once: true })
 
       const result = await pipe(
         [data],
@@ -150,7 +157,7 @@ class DefaultPingService implements Startable, PingService {
 
       throw err
     } finally {
-      options.signal.removeEventListener('abort', onAbort)
+      options.signal?.removeEventListener('abort', onAbort)
       if (stream != null) {
         await stream.close()
       }