libp2p 0.46.18 → 0.46.19-70d5efc2e

package/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
+  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,7 +249,7 @@ 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 () => {
@@ -257,19 +257,19 @@ export class AutoDial implements Startable {
 
         // 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)
     }

package/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,6 +32,7 @@ export class ConnectionPruner {
   private readonly peerStore: PeerStore
   private readonly allow: Multiaddr[]
   private readonly events: TypedEventTarget<Libp2pEvents>
+  readonly #log: Logger
 
   constructor (components: ConnectionPrunerComponents, init: ConnectionPrunerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
@@ -41,12 +40,13 @@ export class ConnectionPruner {
     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)
         }
       })
     )

package/src/connection-manager/dial-queue.ts

@@ -1,6 +1,5 @@
 import { AbortError, CodeError } from '@libp2p/interface/errors'
 import { setMaxListeners } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { type Multiaddr, type Resolver, resolvers } from '@multiformats/multiaddr'
@@ -19,7 +18,7 @@ import {
   LAST_DIAL_FAILURE_KEY
 } from './constants.js'
 import { combineSignals, resolveMultiaddrs } from './utils.js'
-import type { AddressSorter, AbortOptions, PendingDial } from '@libp2p/interface'
+import type { AddressSorter, AbortOptions, PendingDial, ComponentLogger, Logger } from '@libp2p/interface'
 import type { Connection } from '@libp2p/interface/connection'
 import type { ConnectionGater } from '@libp2p/interface/connection-gater'
 import type { Metric, Metrics } from '@libp2p/interface/metrics'
@@ -27,8 +26,6 @@ import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Address, PeerStore } from '@libp2p/interface/peer-store'
 import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
-const log = logger('libp2p:connection-manager:dial-queue')
-
 export interface PendingDialTarget {
   resolve(value: any): void
   reject(err: Error): void
@@ -70,6 +67,7 @@ interface DialQueueComponents {
   peerStore: PeerStore
   transportManager: TransportManager
   connectionGater: ConnectionGater
+  logger: ComponentLogger
 }
 
 export class DialQueue {
@@ -87,6 +85,7 @@ export class DialQueue {
   private readonly pendingDialCount?: Metric
   private readonly shutDownController: AbortController
   private readonly connections: PeerMap<Connection[]>
+  readonly #log: Logger
 
   constructor (components: DialQueueComponents, init: DialerInit = {}) {
     this.addressSorter = init.addressSorter ?? defaultOptions.addressSorter
@@ -94,6 +93,7 @@ export class DialQueue {
     this.maxParallelDialsPerPeer = init.maxParallelDialsPerPeer ?? defaultOptions.maxParallelDialsPerPeer
     this.dialTimeout = init.dialTimeout ?? defaultOptions.dialTimeout
     this.connections = init.connections ?? new PeerMap()
+    this.#log = components.logger.forComponent('libp2p:connection-manager:dial-queue')
 
     this.peerId = components.peerId
     this.peerStore = components.peerStore
@@ -133,7 +133,7 @@ export class DialQueue {
     })
     // a started job errored
     this.queue.on('error', (err) => {
-      log.error('error in dial queue', err)
+      this.#log.error('error in dial queue', err)
       this.pendingDialCount?.update(this.queue.size)
       this.inProgressDialCount?.update(this.queue.pending)
     })
@@ -205,7 +205,7 @@ export class DialQueue {
     })
 
     if (existingConnection != null) {
-      log('already connected to %a', existingConnection.remoteAddr)
+      this.#log('already connected to %a', existingConnection.remoteAddr)
       return existingConnection
     }
 
@@ -226,12 +226,12 @@ export class DialQueue {
     })
 
     if (existingDial != null) {
-      log('joining existing dial target for %p', peerId)
+      this.#log('joining existing dial target for %p', peerId)
       signal.clear()
       return existingDial.promise
     }
 
-    log('creating dial target for', addrsToDial.map(({ multiaddr }) => multiaddr.toString()))
+    this.#log('creating dial target for', addrsToDial.map(({ multiaddr }) => multiaddr.toString()))
     // @ts-expect-error .promise property is set below
     const pendingDial: PendingDialInternal = {
       id: randomId(),
@@ -252,7 +252,7 @@ export class DialQueue {
         signal.clear()
       })
       .catch(async err => {
-        log.error('dial failed to %s', pendingDial.multiaddrs.map(ma => ma.toString()).join(', '), err)
+        this.#log.error('dial failed to %s', pendingDial.multiaddrs.map(ma => ma.toString()).join(', '), err)
 
         if (peerId != null) {
           // record the last failed dial
@@ -263,7 +263,7 @@ export class DialQueue {
               }
             })
           } catch (err: any) {
-            log.error('could not update last dial failure key for %p', peerId, err)
+            this.#log.error('could not update last dial failure key for %p', peerId, err)
           }
         }
 
@@ -294,12 +294,12 @@ export class DialQueue {
     })
 
     if (existingConnection != null) {
-      log('already connected to %a', existingConnection.remoteAddr)
+      this.#log('already connected to %a', existingConnection.remoteAddr)
       await connection.close()
       return existingConnection
     }
 
-    log('connection opened to %a', connection.remoteAddr)
+    this.#log('connection opened to %a', connection.remoteAddr)
     return connection
   }
 
@@ -334,11 +334,11 @@ export class DialQueue {
 
       // if just a peer id was passed, load available multiaddrs for this peer from the address book
       if (addrs.length === 0) {
-        log('loading multiaddrs for %p', peerId)
+        this.#log('loading multiaddrs for %p', peerId)
         try {
           const peer = await this.peerStore.get(peerId)
           addrs.push(...peer.addresses)
-          log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
+          this.#log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
         } catch (err: any) {
           if (err.code !== codes.ERR_NOT_FOUND) {
             throw err
@@ -350,7 +350,10 @@ export class DialQueue {
     // resolve addresses - this can result in a one-to-many translation when dnsaddrs are resolved
     let resolvedAddresses = (await Promise.all(
       addrs.map(async addr => {
-        const result = await resolveMultiaddrs(addr.multiaddr, options)
+        const result = await resolveMultiaddrs(addr.multiaddr, {
+          ...options,
+          log: this.#log
+        })
 
         if (result.length === 1 && result[0].equals(addr.multiaddr)) {
           return addr
@@ -422,8 +425,8 @@ export class DialQueue {
     const dedupedMultiaddrs = [...dedupedAddrs.values()]
 
     if (dedupedMultiaddrs.length === 0 || dedupedMultiaddrs.length > this.maxPeerAddrsToDial) {
-      log('addresses for %p before filtering', peerId ?? 'unknown peer', resolvedAddresses.map(({ multiaddr }) => multiaddr.toString()))
-      log('addresses for %p after filtering', peerId ?? 'unknown peer', dedupedMultiaddrs.map(({ multiaddr }) => multiaddr.toString()))
+      this.#log('addresses for %p before filtering', peerId ?? 'unknown peer', resolvedAddresses.map(({ multiaddr }) => multiaddr.toString()))
+      this.#log('addresses for %p after filtering', peerId ?? 'unknown peer', dedupedMultiaddrs.map(({ multiaddr }) => multiaddr.toString()))
     }
 
     // make sure we actually have some addresses to dial
@@ -467,7 +470,7 @@ export class DialQueue {
         concurrency: this.maxParallelDialsPerPeer
       })
       peerDialQueue.on('error', (err) => {
-        log.error('error dialling', err)
+        this.#log.error('error dialling', err)
       })
 
       const conn = await Promise.any(pendingDial.multiaddrs.map(async (addr, i) => {
@@ -480,13 +483,13 @@ export class DialQueue {
         // let any signal abort the dial
         const signal = combineSignals(controller.signal, options.signal)
         signal.addEventListener('abort', () => {
-          log('dial to %a aborted', addr)
+          this.#log('dial to %a aborted', addr)
         })
         const deferred = pDefer<Connection>()
 
         await peerDialQueue.add(async () => {
           if (signal.aborted) {
-            log('dial to %a was aborted before reaching the head of the peer dial queue', addr)
+            this.#log('dial to %a was aborted before reaching the head of the peer dial queue', addr)
             deferred.reject(new AbortError())
             return
           }
@@ -495,7 +498,7 @@ export class DialQueue {
           await this.queue.add(async () => {
             try {
               if (signal.aborted) {
-                log('dial to %a was aborted before reaching the head of the dial queue', addr)
+                this.#log('dial to %a was aborted before reaching the head of the dial queue', addr)
                 deferred.reject(new AbortError())
                 return
               }
@@ -510,10 +513,10 @@ export class DialQueue {
 
               if (controller.signal.aborted) {
                 // another dial succeeded faster than this one
-                log('multiple dials succeeded, closing superfluous connection')
+                this.#log('multiple dials succeeded, closing superfluous connection')
 
                 conn.close().catch(err => {
-                  log.error('error closing superfluous connection', err)
+                  this.#log.error('error closing superfluous connection', err)
                 })
 
                 deferred.reject(new AbortError())
@@ -530,13 +533,13 @@ export class DialQueue {
                 }
               })
 
-              log('dial to %a succeeded', addr)
+              this.#log('dial to %a succeeded', addr)
 
               // resolve the connection promise
               deferred.resolve(conn)
             } catch (err: any) {
               // something only went wrong if our signal was not aborted
-              log.error('error during dial of %a', addr, err)
+              this.#log.error('error during dial of %a', addr, err)
               deferred.reject(err)
             }
           }, {

package/src/connection-manager/index.ts

@@ -1,6 +1,5 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { KEEP_ALIVE } from '@libp2p/interface/peer-store/tags'
-import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { type Multiaddr, type Resolver, multiaddr } from '@multiformats/multiaddr'
@@ -12,7 +11,7 @@ import { AutoDial } from './auto-dial.js'
 import { ConnectionPruner } from './connection-pruner.js'
 import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PARALLEL_DIALS_PER_PEER, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
 import { DialQueue } from './dial-queue.js'
-import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions } from '@libp2p/interface'
+import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
 import type { Connection, MultiaddrConnection } from '@libp2p/interface/connection'
 import type { ConnectionGater } from '@libp2p/interface/connection-gater'
 import type { TypedEventTarget } from '@libp2p/interface/events'
@@ -23,8 +22,6 @@ import type { Startable } from '@libp2p/interface/startable'
 import type { ConnectionManager, OpenConnectionOptions } from '@libp2p/interface-internal/connection-manager'
 import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
-const log = logger('libp2p:connection-manager')
-
 const DEFAULT_DIAL_PRIORITY = 50
 
 export interface ConnectionManagerInit {
@@ -166,6 +163,7 @@ export interface DefaultConnectionManagerComponents {
   transportManager: TransportManager
   connectionGater: ConnectionGater
   events: TypedEventTarget<Libp2pEvents>
+  logger: ComponentLogger
 }
 
 /**
@@ -188,6 +186,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
   private readonly peerStore: PeerStore
   private readonly metrics?: Metrics
   private readonly events: TypedEventTarget<Libp2pEvents>
+  readonly #log: Logger
 
   constructor (components: DefaultConnectionManagerComponents, init: ConnectionManagerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
@@ -206,6 +205,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.peerStore = components.peerStore
     this.metrics = components.metrics
     this.events = components.events
+    this.#log = components.logger.forComponent('libp2p:connection-manager')
 
     this.onConnect = this.onConnect.bind(this)
     this.onDisconnect = this.onDisconnect.bind(this)
@@ -229,7 +229,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.autoDial = new AutoDial({
       connectionManager: this,
       peerStore: components.peerStore,
-      events: components.events
+      events: components.events,
+      logger: components.logger
     }, {
       minConnections,
       autoDialConcurrency: init.autoDialConcurrency ?? defaultOptions.autoDialConcurrency,
@@ -241,7 +242,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.connectionPruner = new ConnectionPruner({
       connectionManager: this,
       peerStore: components.peerStore,
-      events: components.events
+      events: components.events,
+      logger: components.logger
     }, {
       maxConnections: this.maxConnections,
       allow: this.allow
@@ -252,7 +254,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       metrics: components.metrics,
       peerStore: components.peerStore,
       transportManager: components.transportManager,
-      connectionGater: components.connectionGater
+      connectionGater: components.connectionGater,
+      logger: components.logger
     }, {
       addressSorter: init.addressSorter ?? defaultAddressSort,
       maxParallelDials: init.maxParallelDials ?? MAX_PARALLEL_DIALS,
@@ -356,7 +359,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.autoDial.start()
 
     this.started = true
-    log('started')
+    this.#log('started')
   }
 
   async afterStart (): Promise<void> {
@@ -373,13 +376,13 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
           keepAlivePeers.map(async peer => {
             await this.openConnection(peer.id)
               .catch(err => {
-                log.error(err)
+                this.#log.error(err)
               })
           })
         )
       })
       .catch(err => {
-        log.error(err)
+        this.#log.error(err)
       })
 
     this.autoDial.afterStart()
@@ -400,22 +403,22 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
           try {
             await connection.close()
           } catch (err) {
-            log.error(err)
+            this.#log.error(err)
           }
         })())
       }
     }
 
-    log('closing %d connections', tasks.length)
+    this.#log('closing %d connections', tasks.length)
     await Promise.all(tasks)
     this.connections.clear()
 
-    log('stopped')
+    this.#log('stopped')
   }
 
   onConnect (evt: CustomEvent<Connection>): void {
     void this._onConnect(evt).catch(err => {
-      log.error(err)
+      this.#log.error(err)
     })
   }
 
@@ -505,12 +508,12 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     const { peerId } = getPeerAddress(peerIdOrMultiaddr)
 
     if (peerId != null && options.force !== true) {
-      log('dial %p', peerId)
+      this.#log('dial %p', peerId)
       const existingConnection = this.getConnections(peerId)
         .find(conn => !conn.transient)
 
       if (existingConnection != null) {
-        log('had an existing non-transient connection to %p', peerId)
+        this.#log('had an existing non-transient connection to %p', peerId)
 
         return existingConnection
       }
@@ -566,7 +569,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     })
 
     if (denyConnection) {
-      log('connection from %a refused - connection remote address was in deny list', maConn.remoteAddr)
+      this.#log('connection from %a refused - connection remote address was in deny list', maConn.remoteAddr)
       return false
     }
 
@@ -583,7 +586,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     // check pending connections
     if (this.incomingPendingConnections === this.maxIncomingPendingConnections) {
-      log('connection from %a refused - incomingPendingConnections exceeded by host', maConn.remoteAddr)
+      this.#log('connection from %a refused - incomingPendingConnections exceeded by host', maConn.remoteAddr)
       return false
     }
 
@@ -593,7 +596,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       try {
         await this.inboundConnectionRateLimiter.consume(host, 1)
       } catch {
-        log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, host)
+        this.#log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, host)
         return false
       }
     }
@@ -604,7 +607,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       return true
     }
 
-    log('connection from %a refused - maxConnections exceeded', maConn.remoteAddr)
+    this.#log('connection from %a refused - maxConnections exceeded', maConn.remoteAddr)
     return false
   }