@libp2p/webrtc 3.2.10 → 3.2.11-05b52d69c

package/src/maconn.ts

@@ -1,12 +1,10 @@
-import { logger } from '@libp2p/logger'
 import { nopSink, nopSource } from './util.js'
+import type { ComponentLogger, Logger } from '@libp2p/interface'
 import type { MultiaddrConnection, MultiaddrConnectionTimeline } from '@libp2p/interface/connection'
 import type { CounterGroup } from '@libp2p/interface/metrics'
 import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
 import type { Source, Sink } from 'it-stream-types'
 
-const log = logger('libp2p:webrtc:maconn')
-
 interface WebRTCMultiaddrConnectionInit {
   /**
    * WebRTC Peer Connection
@@ -29,7 +27,12 @@ interface WebRTCMultiaddrConnectionInit {
   metrics?: CounterGroup
 }
 
+export interface WebRTCMultiaddrConnectionComponents {
+  logger: ComponentLogger
+}
+
 export class WebRTCMultiaddrConnection implements MultiaddrConnection {
+  private readonly log: Logger
   /**
    * WebRTC Peer Connection
    */
@@ -60,7 +63,8 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
    */
   sink: Sink<Source<Uint8Array>, Promise<void>> = nopSink
 
-  constructor (init: WebRTCMultiaddrConnectionInit) {
+  constructor (components: WebRTCMultiaddrConnectionComponents, init: WebRTCMultiaddrConnectionInit) {
+    this.log = components.logger.forComponent('libp2p:webrtc:maconn')
     this.remoteAddr = init.remoteAddr
     this.timeline = init.timeline
     this.peerConnection = init.peerConnection
@@ -68,7 +72,7 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
     const initialState = this.peerConnection.connectionState
 
     this.peerConnection.onconnectionstatechange = () => {
-      log.trace('peer connection state change', this.peerConnection.connectionState, 'initial state', initialState)
+      this.log.trace('peer connection state change', this.peerConnection.connectionState, 'initial state', initialState)
 
       if (this.peerConnection.connectionState === 'disconnected' || this.peerConnection.connectionState === 'failed' || this.peerConnection.connectionState === 'closed') {
         // nothing else to do but close the connection
@@ -78,7 +82,7 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
   }
 
   async close (options?: AbortOptions): Promise<void> {
-    log.trace('closing connection')
+    this.log.trace('closing connection')
 
     this.peerConnection.close()
     this.timeline.close = Date.now()
@@ -86,7 +90,7 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
   }
 
   abort (err: Error): void {
-    log.error('closing connection due to error', err)
+    this.log.error('closing connection due to error', err)
 
     this.peerConnection.close()
     this.timeline.close = Date.now()

package/src/muxer.ts

@@ -1,7 +1,7 @@
-import { logger } from '@libp2p/logger'
 import { createStream } from './stream.js'
 import { drainAndClose, nopSink, nopSource } from './util.js'
 import type { DataChannelOptions } from './index.js'
+import type { ComponentLogger, Logger } from '@libp2p/interface'
 import type { Stream } from '@libp2p/interface/connection'
 import type { CounterGroup } from '@libp2p/interface/metrics'
 import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface/stream-muxer'
@@ -9,8 +9,6 @@ import type { AbortOptions } from '@multiformats/multiaddr'
 import type { Source, Sink } from 'it-stream-types'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-const log = logger('libp2p:webrtc:muxer')
-
 const PROTOCOL = '/webrtc'
 
 export interface DataChannelMuxerFactoryInit {
@@ -32,6 +30,10 @@ export interface DataChannelMuxerFactoryInit {
   dataChannelOptions?: DataChannelOptions
 }
 
+export interface DataChannelMuxerFactoryComponents {
+  logger: ComponentLogger
+}
+
 interface BufferedStream {
   stream: Stream
   channel: RTCDataChannel
@@ -48,8 +50,10 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
   private bufferedStreams: BufferedStream[] = []
   private readonly metrics?: CounterGroup
   private readonly dataChannelOptions?: DataChannelOptions
+  private readonly components: DataChannelMuxerFactoryComponents
 
-  constructor (init: DataChannelMuxerFactoryInit) {
+  constructor (components: DataChannelMuxerFactoryComponents, init: DataChannelMuxerFactoryInit) {
+    this.components = components
     this.peerConnection = init.peerConnection
     this.metrics = init.metrics
     this.protocol = init.protocol ?? PROTOCOL
@@ -66,6 +70,7 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
         onEnd: (err) => {
           bufferedStream.onEnd(err)
         },
+        logger: components.logger,
         ...this.dataChannelOptions
       })
 
@@ -80,7 +85,7 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
   }
 
   createStreamMuxer (init?: StreamMuxerInit): StreamMuxer {
-    return new DataChannelMuxer({
+    return new DataChannelMuxer(this.components, {
       ...init,
       peerConnection: this.peerConnection,
       dataChannelOptions: this.dataChannelOptions,
@@ -95,6 +100,10 @@ export interface DataChannelMuxerInit extends DataChannelMuxerFactoryInit, Strea
   streams: BufferedStream[]
 }
 
+export interface DataChannelMuxerComponents {
+  logger: ComponentLogger
+}
+
 /**
  * A libp2p data channel stream muxer
  */
@@ -105,11 +114,15 @@ export class DataChannelMuxer implements StreamMuxer {
   public streams: Stream[]
   public protocol: string
 
+  private readonly log: Logger
   private readonly peerConnection: RTCPeerConnection
   private readonly dataChannelOptions: DataChannelOptions
   private readonly metrics?: CounterGroup
+  private readonly logger: ComponentLogger
 
-  constructor (readonly init: DataChannelMuxerInit) {
+  constructor (components: DataChannelMuxerComponents, readonly init: DataChannelMuxerInit) {
+    this.log = components.logger.forComponent('libp2p:webrtc:muxer')
+    this.logger = components.logger
     this.streams = init.streams.map(s => s.stream)
     this.peerConnection = init.peerConnection
     this.protocol = init.protocol ?? PROTOCOL
@@ -129,6 +142,7 @@ export class DataChannelMuxer implements StreamMuxer {
         onEnd: () => {
           this.#onStreamEnd(stream, channel)
         },
+        logger: this.logger,
         ...this.dataChannelOptions
       })
 
@@ -158,8 +172,14 @@ export class DataChannelMuxer implements StreamMuxer {
   }
 
   #onStreamEnd (stream: Stream, channel: RTCDataChannel): void {
-    log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol)
-    drainAndClose(channel, `${stream.direction} ${stream.id} ${stream.protocol}`, this.dataChannelOptions.drainTimeout)
+    this.log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol)
+    drainAndClose(
+      channel,
+      `${stream.direction} ${stream.id} ${stream.protocol}`,
+      this.dataChannelOptions.drainTimeout, {
+        log: this.log
+      }
+    )
     this.streams = this.streams.filter(s => s.id !== stream.id)
     this.metrics?.increment({ stream_end: true })
     this.init?.onStreamEnd?.(stream)
@@ -206,6 +226,7 @@ export class DataChannelMuxer implements StreamMuxer {
       onEnd: () => {
         this.#onStreamEnd(stream, channel)
       },
+      logger: this.logger,
       ...this.dataChannelOptions
     })
     this.streams.push(stream)

package/src/private-to-private/initiate-connection.ts

@@ -1,5 +1,4 @@
 import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { pbStream } from 'it-protobuf-stream'
 import pDefer, { type DeferredPromise } from 'p-defer'
@@ -8,21 +7,20 @@ import { Message } from './pb/message.js'
 import { SIGNALING_PROTO_ID, splitAddr, type WebRTCTransportMetrics } from './transport.js'
 import { readCandidatesUntilConnected, resolveOnConnected } from './util.js'
 import type { DataChannelOptions } from '../index.js'
+import type { LoggerOptions } from '@libp2p/interface'
 import type { Connection } from '@libp2p/interface/connection'
 import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 import type { IncomingStreamData } from '@libp2p/interface-internal/registrar'
 import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:webrtc:initiate-connection')
-
 export interface IncomingStreamOpts extends IncomingStreamData {
   rtcConfiguration?: RTCConfiguration
   dataChannelOptions?: Partial<DataChannelOptions>
   signal: AbortSignal
 }
 
-export interface ConnectOptions {
+export interface ConnectOptions extends LoggerOptions {
   peerConnection: RTCPeerConnection
   multiaddr: Multiaddr
   connectionManager: ConnectionManager
@@ -32,7 +30,7 @@ export interface ConnectOptions {
   metrics?: WebRTCTransportMetrics
 }
 
-export async function initiateConnection ({ peerConnection, signal, metrics, multiaddr: ma, connectionManager, transportManager }: ConnectOptions): Promise<{ remoteAddress: Multiaddr }> {
+export async function initiateConnection ({ peerConnection, signal, metrics, multiaddr: ma, connectionManager, transportManager, log }: ConnectOptions): Promise<{ remoteAddress: Multiaddr }> {
   const { baseAddr } = splitAddr(ma)
 
   metrics?.dialerEvents.increment({ open: true })
@@ -147,7 +145,8 @@ export async function initiateConnection ({ peerConnection, signal, metrics, mul
 
       await readCandidatesUntilConnected(connectedPromise, peerConnection, messageStream, {
         direction: 'initiator',
-        signal
+        signal,
+        log
       })
 
       log.trace('initiator connected, closing init channel')

package/src/private-to-private/signaling-stream-handler.ts

@@ -1,21 +1,20 @@
 import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { pbStream } from 'it-protobuf-stream'
 import pDefer, { type DeferredPromise } from 'p-defer'
 import { type RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
 import { readCandidatesUntilConnected, resolveOnConnected } from './util.js'
+import type { Logger } from '@libp2p/interface'
 import type { IncomingStreamData } from '@libp2p/interface-internal/registrar'
 
-const log = logger('libp2p:webrtc:signaling-stream-handler')
-
 export interface IncomingStreamOpts extends IncomingStreamData {
   peerConnection: RTCPeerConnection
   signal: AbortSignal
+  log: Logger
 }
 
-export async function handleIncomingStream ({ peerConnection, stream, signal, connection }: IncomingStreamOpts): Promise<{ remoteAddress: Multiaddr }> {
+export async function handleIncomingStream ({ peerConnection, stream, signal, connection, log }: IncomingStreamOpts): Promise<{ remoteAddress: Multiaddr }> {
   log.trace('new inbound signaling stream')
 
   const messageStream = pbStream(stream).pb(Message)
@@ -104,7 +103,8 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
     // wait until candidates are connected
     await readCandidatesUntilConnected(connectedPromise, peerConnection, messageStream, {
       direction: 'recipient',
-      signal
+      signal,
+      log
     })
 
     log.trace('recipient connected, closing signaling stream')

package/src/private-to-private/transport.ts

@@ -1,6 +1,5 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { type CreateListenerOptions, type DialOptions, symbol, type Transport, type Listener, type Upgrader } from '@libp2p/interface/transport'
-import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { WebRTC } from '@multiformats/multiaddr-matcher'
@@ -12,6 +11,7 @@ import { initiateConnection } from './initiate-connection.js'
 import { WebRTCPeerListener } from './listener.js'
 import { handleIncomingStream } from './signaling-stream-handler.js'
 import type { DataChannelOptions } from '../index.js'
+import type { ComponentLogger, Logger } from '@libp2p/interface'
 import type { Connection } from '@libp2p/interface/connection'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { CounterGroup, Metrics } from '@libp2p/interface/src/metrics/index.js'
@@ -20,8 +20,6 @@ import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/r
 import type { ConnectionManager } from '@libp2p/interface-internal/src/connection-manager/index.js'
 import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
-const log = logger('libp2p:webrtc:peer')
-
 const WEBRTC_TRANSPORT = '/webrtc'
 const CIRCUIT_RELAY_TRANSPORT = '/p2p-circuit'
 export const SIGNALING_PROTO_ID = '/webrtc-signaling/0.0.1'
@@ -45,6 +43,7 @@ export interface WebRTCTransportComponents {
   transportManager: TransportManager
   connectionManager: ConnectionManager
   metrics?: Metrics
+  logger: ComponentLogger
 }
 
 export interface WebRTCTransportMetrics {
@@ -53,6 +52,7 @@ export interface WebRTCTransportMetrics {
 }
 
 export class WebRTCTransport implements Transport, Startable {
+  private readonly log: Logger
   private _started = false
   private readonly metrics?: WebRTCTransportMetrics
   private readonly shutdownController: AbortController
@@ -61,6 +61,7 @@ export class WebRTCTransport implements Transport, Startable {
     private readonly components: WebRTCTransportComponents,
     private readonly init: WebRTCTransportInit = {}
   ) {
+    this.log = components.logger.forComponent('libp2p:webrtc')
     this.shutdownController = new AbortController()
 
     if (components.metrics != null) {
@@ -83,7 +84,7 @@ export class WebRTCTransport implements Transport, Startable {
 
   async start (): Promise<void> {
     await this.components.registrar.handle(SIGNALING_PROTO_ID, (data: IncomingStreamData) => {
-      this._onProtocol(data).catch(err => { log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err) })
+      this._onProtocol(data).catch(err => { this.log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err) })
     }, {
       runOnTransientConnection: true
     })
@@ -118,10 +119,10 @@ export class WebRTCTransport implements Transport, Startable {
    * <relay address>/p2p/<relay-peer>/p2p-circuit/webrtc/p2p/<destination-peer>
   */
   async dial (ma: Multiaddr, options: DialOptions): Promise<Connection> {
-    log.trace('dialing address: %a', ma)
+    this.log.trace('dialing address: %a', ma)
 
     const peerConnection = new RTCPeerConnection(this.init.rtcConfiguration)
-    const muxerFactory = new DataChannelMuxerFactory({
+    const muxerFactory = new DataChannelMuxerFactory(this.components, {
       peerConnection,
       dataChannelOptions: this.init.dataChannel
     })
@@ -132,10 +133,11 @@ export class WebRTCTransport implements Transport, Startable {
       dataChannelOptions: this.init.dataChannel,
       signal: options.signal,
       connectionManager: this.components.connectionManager,
-      transportManager: this.components.transportManager
+      transportManager: this.components.transportManager,
+      log: this.log
     })
 
-    const webRTCConn = new WebRTCMultiaddrConnection({
+    const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
       peerConnection,
       timeline: { open: Date.now() },
       remoteAddr: remoteAddress,
@@ -157,7 +159,7 @@ export class WebRTCTransport implements Transport, Startable {
   async _onProtocol ({ connection, stream }: IncomingStreamData): Promise<void> {
     const signal = AbortSignal.timeout(this.init.inboundConnectionTimeout ?? INBOUND_CONNECTION_TIMEOUT)
     const peerConnection = new RTCPeerConnection(this.init.rtcConfiguration)
-    const muxerFactory = new DataChannelMuxerFactory({
+    const muxerFactory = new DataChannelMuxerFactory(this.components, {
       peerConnection,
       dataChannelOptions: this.init.dataChannel
     })
@@ -167,10 +169,11 @@ export class WebRTCTransport implements Transport, Startable {
         peerConnection,
         connection,
         stream,
-        signal
+        signal,
+        log: this.log
       })
 
-      const webRTCConn = new WebRTCMultiaddrConnection({
+      const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
         peerConnection,
         timeline: { open: (new Date()).getTime() },
         remoteAddr: remoteAddress,
@@ -201,7 +204,7 @@ export class WebRTCTransport implements Transport, Startable {
     const shutDownListener = (): void => {
       webRTCConn.close()
         .catch(err => {
-          log.error('could not close WebRTCMultiaddrConnection', err)
+          this.log.error('could not close WebRTCMultiaddrConnection', err)
         })
     }
 

package/src/private-to-private/util.ts

@@ -1,5 +1,4 @@
 import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
 import { abortableSource } from 'abortable-iterator'
 import { anySignal } from 'any-signal'
 import * as lp from 'it-length-prefixed'
@@ -7,13 +6,12 @@ import { AbortError, raceSignal } from 'race-signal'
 import { isFirefox } from '../util.js'
 import { RTCIceCandidate } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
+import type { LoggerOptions } from '@libp2p/interface'
 import type { Stream } from '@libp2p/interface/connection'
 import type { AbortOptions, MessageStream } from 'it-protobuf-stream'
 import type { DeferredPromise } from 'p-defer'
 
-const log = logger('libp2p:webrtc:peer:util')
-
-export interface ReadCandidatesOptions extends AbortOptions {
+export interface ReadCandidatesOptions extends AbortOptions, LoggerOptions {
   direction: string
 }
 
@@ -47,7 +45,7 @@ export const readCandidatesUntilConnected = async (connectedPromise: DeferredPro
       let candidateInit = JSON.parse(message.data ?? 'null')
 
       if (candidateInit === '') {
-        log.trace('end-of-candidates for this generation received')
+        options.log.trace('end-of-candidates for this generation received')
         candidateInit = {
           candidate: '',
           sdpMid: '0',
@@ -56,7 +54,7 @@ export const readCandidatesUntilConnected = async (connectedPromise: DeferredPro
       }
 
       if (candidateInit === null) {
-        log.trace('end-of-candidates received')
+        options.log.trace('end-of-candidates received')
         candidateInit = {
           candidate: null,
           sdpMid: '0',
@@ -68,16 +66,16 @@ export const readCandidatesUntilConnected = async (connectedPromise: DeferredPro
       // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
       const candidate = new RTCIceCandidate(candidateInit)
 
-      log.trace('%s received new ICE candidate', options.direction, candidate)
+      options.log.trace('%s received new ICE candidate', options.direction, candidate)
 
       try {
         await pc.addIceCandidate(candidate)
       } catch (err) {
-        log.error('%s bad candidate received', options.direction, err)
+        options.log.error('%s bad candidate received', options.direction, err)
       }
     }
   } catch (err) {
-    log.error('%s error parsing ICE candidate', options.direction, err)
+    options.log.error('%s error parsing ICE candidate', options.direction, err)
   } finally {
     signal.clear()
   }
@@ -95,7 +93,6 @@ export const readCandidatesUntilConnected = async (connectedPromise: DeferredPro
 
 export function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<void>): void {
   pc[isFirefox ? 'oniceconnectionstatechange' : 'onconnectionstatechange'] = (_) => {
-    log.trace('receiver peerConnectionState state change: %s', pc.connectionState)
     switch (isFirefox ? pc.iceConnectionState : pc.connectionState) {
       case 'connected':
         promise.resolve()

package/src/private-to-public/sdp.ts

@@ -1,24 +1,22 @@
-import { logger } from '@libp2p/logger'
 import { bases } from 'multiformats/basics'
 import * as multihashes from 'multihashes'
 import { inappropriateMultiaddr, invalidArgument, invalidFingerprint, unsupportedHashAlgorithm } from '../error.js'
 import { CERTHASH_CODE } from './transport.js'
+import type { LoggerOptions } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { HashCode, HashName } from 'multihashes'
 
-const log = logger('libp2p:webrtc:sdp')
-
 /**
  * Get base2 | identity decoders
  */
 // @ts-expect-error - Not easy to combine these types.
 export const mbdecoder: any = Object.values(bases).map(b => b.decoder).reduce((d, b) => d.or(b))
 
-export function getLocalFingerprint (pc: RTCPeerConnection): string | undefined {
+export function getLocalFingerprint (pc: RTCPeerConnection, options: LoggerOptions): string | undefined {
   // try to fetch fingerprint from local certificate
   const localCert = pc.getConfiguration().certificates?.at(0)
   if (localCert == null || localCert.getFingerprints == null) {
-    log.trace('fetching fingerprint from local SDP')
+    options.log.trace('fetching fingerprint from local SDP')
     const localDescription = pc.localDescription
     if (localDescription == null) {
       return undefined
@@ -26,7 +24,7 @@ export function getLocalFingerprint (pc: RTCPeerConnection): string | undefined
     return getFingerprintFromSdp(localDescription.sdp)
   }
 
-  log.trace('fetching fingerprint from local certificate')
+  options.log.trace('fetching fingerprint from local certificate')
 
   if (localCert.getFingerprints().length === 0) {
     return undefined
@@ -55,8 +53,6 @@ function ipv (ma: Multiaddr): string {
     }
   }
 
-  log('Warning: multiaddr does not appear to contain IP4 or IP6, defaulting to IP6', ma)
-
   return 'IP6'
 }
 

package/src/private-to-public/transport.ts

@@ -1,6 +1,5 @@
 import { noise as Noise } from '@chainsafe/libp2p-noise'
 import { type CreateListenerOptions, symbol, type Transport, type Listener } from '@libp2p/interface/transport'
-import { logger } from '@libp2p/logger'
 import * as p from '@libp2p/peer-id'
 import { protocols } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
@@ -17,13 +16,12 @@ import * as sdp from './sdp.js'
 import { genUfrag } from './util.js'
 import type { WebRTCDialOptions } from './options.js'
 import type { DataChannelOptions } from '../index.js'
+import type { ComponentLogger, Logger } from '@libp2p/interface'
 import type { Connection } from '@libp2p/interface/connection'
 import type { CounterGroup, Metrics } from '@libp2p/interface/metrics'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:webrtc:transport')
-
 /**
  * The time to wait, in milliseconds, for the data channel handshake to complete
  */
@@ -49,6 +47,7 @@ export const CERTHASH_CODE: number = protocols('certhash').code
 export interface WebRTCDirectTransportComponents {
   peerId: PeerId
   metrics?: Metrics
+  logger: ComponentLogger
 }
 
 export interface WebRTCMetrics {
@@ -60,10 +59,12 @@ export interface WebRTCTransportDirectInit {
 }
 
 export class WebRTCDirectTransport implements Transport {
+  private readonly log: Logger
   private readonly metrics?: WebRTCMetrics
   private readonly components: WebRTCDirectTransportComponents
   private readonly init: WebRTCTransportDirectInit
   constructor (components: WebRTCDirectTransportComponents, init: WebRTCTransportDirectInit = {}) {
+    this.log = components.logger.forComponent('libp2p:webrtc-direct')
     this.components = components
     this.init = init
     if (components.metrics != null) {
@@ -81,7 +82,7 @@ export class WebRTCDirectTransport implements Transport {
    */
   async dial (ma: Multiaddr, options: WebRTCDialOptions): Promise<Connection> {
     const rawConn = await this._connect(ma, options)
-    log('dialing address: %a', ma)
+    this.log('dialing address: %a', ma)
     return rawConn
   }
 
@@ -144,7 +145,7 @@ export class WebRTCDirectTransport implements Transport {
         const handshakeDataChannel = peerConnection.createDataChannel('', { negotiated: true, id: 0 })
         const handshakeTimeout = setTimeout(() => {
           const error = `Data channel was never opened: state: ${handshakeDataChannel.readyState}`
-          log.error(error)
+          this.log.error(error)
           this.metrics?.dialerEvents.increment({ open_error: true })
           reject(dataChannelError('data', error))
         }, HANDSHAKE_TIMEOUT_MS)
@@ -159,7 +160,7 @@ export class WebRTCDirectTransport implements Transport {
           clearTimeout(handshakeTimeout)
           const errorTarget = event.target?.toString() ?? 'not specified'
           const error = `Error opening a data channel for handshaking: ${errorTarget}`
-          log.error(error)
+          this.log.error(error)
           // NOTE: We use unknown error here but this could potentially be considered a reset by some standards.
           this.metrics?.dialerEvents.increment({ unknown_error: true })
           reject(dataChannelError('data', error))
@@ -194,7 +195,12 @@ export class WebRTCDirectTransport implements Transport {
       // we pass in undefined for these parameters.
       const noise = Noise({ prologueBytes: fingerprintsPrologue })()
 
-      const wrappedChannel = createStream({ channel: handshakeDataChannel, direction: 'inbound', ...(this.init.dataChannel ?? {}) })
+      const wrappedChannel = createStream({
+        channel: handshakeDataChannel,
+        direction: 'inbound',
+        logger: this.components.logger,
+        ...(this.init.dataChannel ?? {})
+      })
       const wrappedDuplex = {
         ...wrappedChannel,
         sink: wrappedChannel.sink.bind(wrappedChannel),
@@ -209,7 +215,7 @@ export class WebRTCDirectTransport implements Transport {
 
       // Creating the connection before completion of the noise
       // handshake ensures that the stream opening callback is set up
-      const maConn = new WebRTCMultiaddrConnection({
+      const maConn = new WebRTCMultiaddrConnection(this.components, {
         peerConnection,
         remoteAddr: ma,
         timeline: {
@@ -226,7 +232,7 @@ export class WebRTCDirectTransport implements Transport {
           case 'disconnected':
           case 'closed':
             maConn.close().catch((err) => {
-              log.error('error closing connection', err)
+              this.log.error('error closing connection', err)
             }).finally(() => {
               // Remove the event listener once the connection is closed
               controller.abort()
@@ -240,7 +246,11 @@ export class WebRTCDirectTransport implements Transport {
       // Track opened peer connection
       this.metrics?.dialerEvents.increment({ peer_connection: true })
 
-      const muxerFactory = new DataChannelMuxerFactory({ peerConnection, metrics: this.metrics?.dialerEvents, dataChannelOptions: this.init.dataChannel })
+      const muxerFactory = new DataChannelMuxerFactory(this.components, {
+        peerConnection,
+        metrics: this.metrics?.dialerEvents,
+        dataChannelOptions: this.init.dataChannel
+      })
 
       // For outbound connections, the remote is expected to start the noise handshake.
       // Therefore, we need to secure an inbound noise connection from the remote.
@@ -262,7 +272,9 @@ export class WebRTCDirectTransport implements Transport {
       throw invalidArgument('no local certificate')
     }
 
-    const localFingerprint = sdp.getLocalFingerprint(pc)
+    const localFingerprint = sdp.getLocalFingerprint(pc, {
+      log: this.log
+    })
     if (localFingerprint == null) {
       throw invalidArgument('no local fingerprint found')
     }

package/src/stream.ts

@@ -1,6 +1,5 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { AbstractStream, type AbstractStreamInit } from '@libp2p/interface/stream-muxer/stream'
-import { logger } from '@libp2p/logger'
 import * as lengthPrefixed from 'it-length-prefixed'
 import { type Pushable, pushable } from 'it-pushable'
 import pDefer from 'p-defer'
@@ -10,7 +9,7 @@ import { raceSignal } from 'race-signal'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { Message } from './pb/message.js'
 import type { DataChannelOptions } from './index.js'
-import type { AbortOptions } from '@libp2p/interface'
+import type { AbortOptions, ComponentLogger } from '@libp2p/interface'
 import type { Direction } from '@libp2p/interface/connection'
 import type { DeferredPromise } from 'p-defer'
 
@@ -22,6 +21,8 @@ export interface WebRTCStreamInit extends AbstractStreamInit, DataChannelOptions
    * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel}
    */
   channel: RTCDataChannel
+
+  logger: ComponentLogger
 }
 
 /**
@@ -379,6 +380,8 @@ export interface WebRTCStreamOptions extends DataChannelOptions {
    * A callback invoked when the channel ends
    */
   onEnd?(err?: Error | undefined): void
+
+  logger: ComponentLogger
 }
 
 export function createStream (options: WebRTCStreamOptions): WebRTCStream {
@@ -386,7 +389,7 @@ export function createStream (options: WebRTCStreamOptions): WebRTCStream {
 
   return new WebRTCStream({
     id: direction === 'inbound' ? (`i${channel.id}`) : `r${channel.id}`,
-    log: logger(`libp2p:webrtc:stream:${direction}:${channel.id}`),
+    log: options.logger.forComponent(`libp2p:webrtc:stream:${direction}:${channel.id}`),
     ...options
   })
 }