chore: make default logger the same as regular logging

packages/interface/src/index.ts

@@ -119,7 +119,7 @@ export interface Logger {
 /**
  * Peer logger component for libp2p
  */
-export interface PeerLogger {
+export interface ComponentLogger {
   forComponent(name: string): Logger
 }
 
@@ -425,7 +425,7 @@ export interface Libp2p<T extends ServiceMap = ServiceMap> extends Startable, Ty
    */
   metrics?: Metrics
 
-  logger: PeerLogger
+  logger: ComponentLogger
 
   /**
    * Get a deduplicated list of peer advertising multiaddrs by concatenating
@@ -645,6 +645,13 @@ export interface AbortOptions {
   signal?: AbortSignal
 }
 
+/**
+ * An object that contains a Logger as the `log` property.
+ */
+export interface LoggerOptions {
+  log: Logger
+}
+
 /**
  * Returns a new type with all fields marked optional.
  *

packages/libp2p/src/components.ts

@@ -1,6 +1,7 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { isStartable, type Startable } from '@libp2p/interface/startable'
-import type { Libp2pEvents, PeerLogger } from '@libp2p/interface'
+import { defaultLogger } from '@libp2p/logger'
+import type { Libp2pEvents, ComponentLogger } from '@libp2p/interface'
 import type { ConnectionProtector } from '@libp2p/interface/connection'
 import type { ConnectionGater } from '@libp2p/interface/connection-gater'
 import type { ContentRouting } from '@libp2p/interface/content-routing'
@@ -18,7 +19,7 @@ import type { Datastore } from 'interface-datastore'
 
 export interface Components extends Record<string, any>, Startable {
   peerId: PeerId
-  logger: PeerLogger
+  logger: ComponentLogger
   events: TypedEventTarget<Libp2pEvents>
   addressManager: AddressManager
   peerStore: PeerStore
@@ -36,7 +37,7 @@ export interface Components extends Record<string, any>, Startable {
 
 export interface ComponentsInit {
   peerId?: PeerId
-  logger?: PeerLogger
+  logger?: ComponentLogger
   events?: TypedEventTarget<Libp2pEvents>
   addressManager?: AddressManager
   peerStore?: PeerStore
@@ -62,6 +63,10 @@ class DefaultComponents implements Startable {
     for (const [key, value] of Object.entries(init)) {
       this.components[key] = value
     }
+
+    if (this.components.logger == null) {
+      this.components.logger = defaultLogger()
+    }
   }
 
   isStarted (): boolean {

packages/libp2p/src/connection-manager/auto-dial.ts

@@ -1,16 +1,13 @@
-import { logger } from '@libp2p/logger'
 import { PeerMap, PeerSet } from '@libp2p/peer-collections'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { PeerJobQueue } from '../utils/peer-job-queue.js'
 import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_DISCOVERED_PEERS_DEBOUNCE, AUTO_DIAL_INTERVAL, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PEER_RETRY_THRESHOLD, AUTO_DIAL_PRIORITY, LAST_DIAL_FAILURE_KEY, MIN_CONNECTIONS } from './constants.js'
-import type { Libp2pEvents } from '@libp2p/interface'
+import type { Libp2pEvents, Logger, ComponentLogger } from '@libp2p/interface'
 import type { TypedEventTarget } from '@libp2p/interface/events'
 import type { PeerStore } from '@libp2p/interface/peer-store'
 import type { Startable } from '@libp2p/interface/startable'
 import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 
-const log = logger('libp2p:connection-manager:auto-dial')
-
 interface AutoDialInit {
   minConnections?: number
   maxQueueLength?: number
@@ -25,6 +22,7 @@ interface AutoDialComponents {
   connectionManager: ConnectionManager
   peerStore: PeerStore
   events: TypedEventTarget<Libp2pEvents>
+  logger: ComponentLogger
 }
 
 const defaultOptions = {
@@ -50,6 +48,7 @@ export class AutoDial implements Startable {
   private autoDialInterval?: ReturnType<typeof setInterval>
   private started: boolean
   private running: boolean
+  private readonly log: Logger
 
   /**
    * Proactively tries to connect to known peers stored in the PeerStore.
@@ -65,20 +64,21 @@ export class AutoDial implements Startable {
     this.autoDialMaxQueueLength = init.maxQueueLength ?? defaultOptions.maxQueueLength
     this.autoDialPeerRetryThresholdMs = init.autoDialPeerRetryThreshold ?? defaultOptions.autoDialPeerRetryThreshold
     this.autoDialDiscoveredPeersDebounce = init.autoDialDiscoveredPeersDebounce ?? defaultOptions.autoDialDiscoveredPeersDebounce
+    this.log = components.logger.forComponent('libp2p:connection-manager:auto-dial')
     this.started = false
     this.running = false
     this.queue = new PeerJobQueue({
       concurrency: init.autoDialConcurrency ?? defaultOptions.autoDialConcurrency
     })
     this.queue.addListener('error', (err) => {
-      log.error('error during auto-dial', err)
+      this.log.error('error during auto-dial', err)
     })
 
     // check the min connection limit whenever a peer disconnects
     components.events.addEventListener('connection:close', () => {
       this.autoDial()
         .catch(err => {
-          log.error(err)
+          this.log.error(err)
         })
     })
 
@@ -93,7 +93,7 @@ export class AutoDial implements Startable {
       debounce = setTimeout(() => {
         this.autoDial()
           .catch(err => {
-            log.error(err)
+            this.log.error(err)
           })
       }, this.autoDialDiscoveredPeersDebounce)
     })
@@ -107,7 +107,7 @@ export class AutoDial implements Startable {
     this.autoDialInterval = setTimeout(() => {
       this.autoDial()
         .catch(err => {
-          log.error('error while autodialing', err)
+          this.log.error('error while autodialing', err)
         })
     }, this.autoDialIntervalMs)
     this.started = true
@@ -116,7 +116,7 @@ export class AutoDial implements Startable {
   afterStart (): void {
     this.autoDial()
       .catch(err => {
-        log.error('error while autodialing', err)
+        this.log.error('error while autodialing', err)
       })
   }
 
@@ -139,24 +139,24 @@ export class AutoDial implements Startable {
     // Already has enough connections
     if (numConnections >= this.minConnections) {
       if (this.minConnections > 0) {
-        log.trace('have enough connections %d/%d', numConnections, this.minConnections)
+        this.log.trace('have enough connections %d/%d', numConnections, this.minConnections)
       }
       return
     }
 
     if (this.queue.size > this.autoDialMaxQueueLength) {
-      log('not enough connections %d/%d but auto dial queue is full', numConnections, this.minConnections)
+      this.log('not enough connections %d/%d but auto dial queue is full', numConnections, this.minConnections)
       return
     }
 
     if (this.running) {
-      log('not enough connections %d/%d - but skipping autodial as it is already running', numConnections, this.minConnections)
+      this.log('not enough connections %d/%d - but skipping autodial as it is already running', numConnections, this.minConnections)
       return
     }
 
     this.running = true
 
-    log('not enough connections %d/%d - will dial peers to increase the number of connections', numConnections, this.minConnections)
+    this.log('not enough connections %d/%d - will dial peers to increase the number of connections', numConnections, this.minConnections)
 
     const dialQueue = new PeerSet(
       // @ts-expect-error boolean filter removes falsy peer IDs
@@ -172,25 +172,25 @@ export class AutoDial implements Startable {
         (peer) => {
           // Remove peers without addresses
           if (peer.addresses.length === 0) {
-            log.trace('not autodialing %p because they have no addresses', peer.id)
+            this.log.trace('not autodialing %p because they have no addresses', peer.id)
             return false
           }
 
           // remove peers we are already connected to
           if (connections.has(peer.id)) {
-            log.trace('not autodialing %p because they are already connected', peer.id)
+            this.log.trace('not autodialing %p because they are already connected', peer.id)
             return false
           }
 
           // remove peers we are already dialling
           if (dialQueue.has(peer.id)) {
-            log.trace('not autodialing %p because they are already being dialed', peer.id)
+            this.log.trace('not autodialing %p because they are already being dialed', peer.id)
             return false
           }
 
           // remove peers already in the autodial queue
           if (this.queue.hasJob(peer.id)) {
-            log.trace('not autodialing %p because they are already being autodialed', peer.id)
+            this.log.trace('not autodialing %p because they are already being autodialed', peer.id)
             return false
           }
 
@@ -249,27 +249,27 @@ export class AutoDial implements Startable {
       return Date.now() - lastDialFailureTimestamp > this.autoDialPeerRetryThresholdMs
     })
 
-    log('selected %d/%d peers to dial', peersThatHaveNotFailed.length, peers.length)
+    this.log('selected %d/%d peers to dial', peersThatHaveNotFailed.length, peers.length)
 
     for (const peer of peersThatHaveNotFailed) {
       this.queue.add(async () => {
         const numConnections = this.connectionManager.getConnectionsMap().size
 
         // Check to see if we still need to auto dial
         if (numConnections >= this.minConnections) {
-          log('got enough connections now %d/%d', numConnections, this.minConnections)
+          this.log('got enough connections now %d/%d', numConnections, this.minConnections)
           this.queue.clear()
           return
         }
 
-        log('connecting to a peerStore stored peer %p', peer.id)
+        this.log('connecting to a peerStore stored peer %p', peer.id)
         await this.connectionManager.openConnection(peer.id, {
           priority: this.autoDialPriority
         })
       }, {
         peerId: peer.id
       }).catch(err => {
-        log.error('could not connect to peerStore stored peer', err)
+        this.log.error('could not connect to peerStore stored peer', err)
       })
     }
 
@@ -279,7 +279,7 @@ export class AutoDial implements Startable {
       this.autoDialInterval = setTimeout(() => {
         this.autoDial()
           .catch(err => {
-            log.error('error while autodialing', err)
+            this.log.error('error while autodialing', err)
           })
       }, this.autoDialIntervalMs)
     }

packages/libp2p/src/connection-manager/connection-pruner.ts

@@ -1,14 +1,11 @@
-import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
 import { MAX_CONNECTIONS } from './constants.js'
-import type { Libp2pEvents } from '@libp2p/interface'
+import type { Libp2pEvents, Logger, ComponentLogger } from '@libp2p/interface'
 import type { TypedEventTarget } from '@libp2p/interface/events'
 import type { PeerStore } from '@libp2p/interface/peer-store'
 import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:connection-manager:connection-pruner')
-
 interface ConnectionPrunerInit {
   maxConnections?: number
   allow?: Multiaddr[]
@@ -18,6 +15,7 @@ interface ConnectionPrunerComponents {
   connectionManager: ConnectionManager
   peerStore: PeerStore
   events: TypedEventTarget<Libp2pEvents>
+  logger: ComponentLogger
 }
 
 const defaultOptions = {
@@ -34,19 +32,21 @@ export class ConnectionPruner {
   private readonly peerStore: PeerStore
   private readonly allow: Multiaddr[]
   private readonly events: TypedEventTarget<Libp2pEvents>
+  private readonly log: Logger
 
   constructor (components: ConnectionPrunerComponents, init: ConnectionPrunerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
     this.allow = init.allow ?? defaultOptions.allow
     this.connectionManager = components.connectionManager
     this.peerStore = components.peerStore
     this.events = components.events
+    this.log = components.logger.forComponent('libp2p:connection-manager:connection-pruner')
 
     // check the max connection limit whenever a peer connects
     components.events.addEventListener('connection:open', () => {
       this.maybePruneConnections()
         .catch(err => {
-          log.error(err)
+          this.log.error(err)
         })
     })
   }
@@ -60,12 +60,12 @@ export class ConnectionPruner {
     const numConnections = connections.length
     const toPrune = Math.max(numConnections - this.maxConnections, 0)
 
-    log('checking max connections limit %d/%d', numConnections, this.maxConnections)
+    this.log('checking max connections limit %d/%d', numConnections, this.maxConnections)
     if (numConnections <= this.maxConnections) {
       return
     }
 
-    log('max connections limit exceeded %d/%d, pruning %d connection(s)', numConnections, this.maxConnections, toPrune)
+    this.log('max connections limit exceeded %d/%d, pruning %d connection(s)', numConnections, this.maxConnections, toPrune)
     const peerValues = new PeerMap<number>()
 
     // work out peer values
@@ -87,7 +87,7 @@ export class ConnectionPruner {
         }, 0))
       } catch (err: any) {
         if (err.code !== 'ERR_NOT_FOUND') {
-          log.error('error loading peer tags', err)
+          this.log.error('error loading peer tags', err)
         }
       }
     }
@@ -124,7 +124,7 @@ export class ConnectionPruner {
     const toClose = []
 
     for (const connection of sortedConnections) {
-      log('too many connections open - closing a connection to %p', connection.remotePeer)
+      this.log('too many connections open - closing a connection to %p', connection.remotePeer)
       // check allow list
       const connectionInAllowList = this.allow.some((ma) => {
         return connection.remoteAddr.toString().startsWith(ma.toString())
@@ -146,7 +146,7 @@ export class ConnectionPruner {
         try {
           await connection.close()
         } catch (err) {
-          log.error(err)
+          this.log.error(err)
         }
       })
     )