livekit-client 1.15.6 → 1.15.8

package/dist/ts4.2/src/room/track/LocalVideoTrack.d.ts

@@ -2,6 +2,7 @@ import type { SignalClient } from '../../api/SignalClient';
 import { VideoLayer, VideoQuality } from '../../proto/livekit_models_pb';
 import { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc_pb';
 import type { VideoSenderStats } from '../stats';
+import type { LoggerOptions } from '../types';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';
 import type { VideoCaptureOptions, VideoCodec } from './options';
@@ -26,7 +27,7 @@ export default class LocalVideoTrack extends LocalTrack {
      * @param constraints MediaTrackConstraints that are being used when restarting or reacquiring tracks
      * @param userProvidedTrack Signals to the SDK whether or not the mediaTrack should be managed (i.e. released and reacquired) internally by the SDK
      */
-    constructor(mediaTrack: MediaStreamTrack, constraints?: MediaTrackConstraints, userProvidedTrack?: boolean);
+    constructor(mediaTrack: MediaStreamTrack, constraints?: MediaTrackConstraints, userProvidedTrack?: boolean, loggerOptions?: LoggerOptions);
     get isSimulcast(): boolean;
     startMonitor(signalClient: SignalClient): void;
     stop(): void;

package/dist/ts4.2/src/room/track/RemoteAudioTrack.d.ts

@@ -1,4 +1,5 @@
 import type { AudioReceiverStats } from '../stats';
+import type { LoggerOptions } from '../types';
 import RemoteTrack from './RemoteTrack';
 import type { AudioOutputOptions } from './options';
 export default class RemoteAudioTrack extends RemoteTrack {
@@ -9,7 +10,7 @@ export default class RemoteAudioTrack extends RemoteTrack {
     private sourceNode?;
     private webAudioPluginNodes;
     private sinkId?;
-    constructor(mediaTrack: MediaStreamTrack, sid: string, receiver?: RTCRtpReceiver, audioContext?: AudioContext, audioOutput?: AudioOutputOptions);
+    constructor(mediaTrack: MediaStreamTrack, sid: string, receiver?: RTCRtpReceiver, audioContext?: AudioContext, audioOutput?: AudioOutputOptions, loggerOptions?: LoggerOptions);
     /**
      * sets the volume for all attached audio elements
      */

package/dist/ts4.2/src/room/track/RemoteTrack.d.ts

@@ -1,8 +1,9 @@
+import type { LoggerOptions } from '../types';
 import { Track } from './Track';
 export default abstract class RemoteTrack extends Track {
     /** @internal */
     receiver?: RTCRtpReceiver;
-    constructor(mediaTrack: MediaStreamTrack, sid: string, kind: Track.Kind, receiver?: RTCRtpReceiver);
+    constructor(mediaTrack: MediaStreamTrack, sid: string, kind: Track.Kind, receiver?: RTCRtpReceiver, loggerOptions?: LoggerOptions);
     /** @internal */
     setMuted(muted: boolean): void;
     /** @internal */

package/dist/ts4.2/src/room/track/RemoteTrackPublication.d.ts

@@ -1,4 +1,5 @@
 import { SubscriptionError, TrackInfo, VideoQuality } from '../../proto/livekit_models_pb';
+import type { LoggerOptions } from '../types';
 import type RemoteTrack from './RemoteTrack';
 import { Track } from './Track';
 import { TrackPublication } from './TrackPublication';
@@ -12,7 +13,7 @@ export default class RemoteTrackPublication extends TrackPublication {
     protected videoDimensions?: Track.Dimensions;
     protected fps?: number;
     protected subscriptionError?: SubscriptionError;
-    constructor(kind: Track.Kind, ti: TrackInfo, autoSubscribe: boolean | undefined);
+    constructor(kind: Track.Kind, ti: TrackInfo, autoSubscribe: boolean | undefined, loggerOptions?: LoggerOptions);
     /**
      * Subscribe or unsubscribe to this remote track
      * @param subscribed true to subscribe to a track, false to unsubscribe

package/dist/ts4.2/src/room/track/RemoteVideoTrack.d.ts

@@ -1,3 +1,4 @@
+import type { LoggerOptions } from '../types';
 import RemoteTrack from './RemoteTrack';
 import type { AdaptiveStreamSettings } from './types';
 export default class RemoteVideoTrack extends RemoteTrack {
@@ -6,7 +7,7 @@ export default class RemoteVideoTrack extends RemoteTrack {
     private adaptiveStreamSettings?;
     private lastVisible?;
     private lastDimensions?;
-    constructor(mediaTrack: MediaStreamTrack, sid: string, receiver?: RTCRtpReceiver, adaptiveStreamSettings?: AdaptiveStreamSettings);
+    constructor(mediaTrack: MediaStreamTrack, sid: string, receiver?: RTCRtpReceiver, adaptiveStreamSettings?: AdaptiveStreamSettings, loggerOptions?: LoggerOptions);
     get isAdaptiveStream(): boolean;
     /**
      * Note: When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, otherwise your video tracks might never start

package/dist/ts4.2/src/room/track/Track.d.ts

@@ -1,7 +1,9 @@
 import type TypedEventEmitter from 'typed-emitter';
 import type { SignalClient } from '../../api/SignalClient';
+import { StructuredLogger } from '../../logger';
 import { TrackSource, TrackType } from '../../proto/livekit_models_pb';
 import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc_pb';
+import type { LoggerOptions } from '../types';
 declare const Track_base: new () => TypedEventEmitter<TrackEventCallbacks>;
 export declare abstract class Track extends Track_base {
     kind: Track.Kind;
@@ -25,9 +27,14 @@ export declare abstract class Track extends Track_base {
     protected _mediaStreamID: string;
     protected isInBackground: boolean;
     private backgroundTimeout;
+    private loggerContextCb;
     protected _currentBitrate: number;
     protected monitorInterval?: ReturnType<typeof setInterval>;
-    protected constructor(mediaTrack: MediaStreamTrack, kind: Track.Kind);
+    protected log: StructuredLogger;
+    protected constructor(mediaTrack: MediaStreamTrack, kind: Track.Kind, loggerOptions?: LoggerOptions);
+    protected get logContext(): {
+        [x: string]: unknown;
+    };
     /** current receive bits per second */
     get currentBitrate(): number;
     get mediaStreamTrack(): MediaStreamTrack;
@@ -59,6 +66,8 @@ export declare abstract class Track extends Track_base {
     protected disable(): void;
     abstract startMonitor(signalClient?: SignalClient): void;
     stopMonitor(): void;
+    /** @internal */
+    updateLoggerOptions(loggerOptions: LoggerOptions): void;
     private recycleElement;
     protected appVisibilityChangedListener: () => void;
     protected handleAppVisibilityChanged(): Promise<void>;

package/dist/ts4.2/src/room/track/TrackPublication.d.ts

@@ -2,6 +2,7 @@ import type TypedEventEmitter from 'typed-emitter';
 import { Encryption_Type } from '../../proto/livekit_models_pb';
 import type { SubscriptionError, TrackInfo } from '../../proto/livekit_models_pb';
 import type { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc_pb';
+import type { LoggerOptions } from '../types';
 import LocalAudioTrack from './LocalAudioTrack';
 import LocalVideoTrack from './LocalVideoTrack';
 import RemoteAudioTrack from './RemoteAudioTrack';
@@ -25,9 +26,14 @@ export declare class TrackPublication extends TrackPublication_base {
     trackInfo?: TrackInfo;
     protected metadataMuted: boolean;
     protected encryption: Encryption_Type;
-    constructor(kind: Track.Kind, id: string, name: string);
+    protected log: import("../../logger").StructuredLogger;
+    private loggerContextCb?;
+    constructor(kind: Track.Kind, id: string, name: string, loggerOptions?: LoggerOptions);
     /** @internal */
     setTrack(track?: Track): void;
+    protected get logContext(): {
+        [x: string]: unknown;
+    };
     get isMuted(): boolean;
     get isEnabled(): boolean;
     get isSubscribed(): boolean;

package/dist/ts4.2/src/room/track/options.d.ts

@@ -149,9 +149,10 @@ export interface ScreenShareCaptureOptions {
         displaySurface?: 'window' | 'browser' | 'monitor';
     };
     /**
-     * capture resolution, defaults to screen resolution
-     * NOTE: In Safari 17, specifying any resolution at all would lead to a low-resolution
-     * capture. https://bugs.webkit.org/show_bug.cgi?id=263015
+     * capture resolution, defaults to 1080 for all browsers other than Safari
+     * On Safari 17, default resolution is not capped, due to a bug, specifying
+     * any resolution at all would lead to a low-resolution capture.
+     * https://bugs.webkit.org/show_bug.cgi?id=263015
      */
     resolution?: VideoResolution;
     /** a CaptureController object instance containing methods that can be used to further manipulate the capture session if included. */
@@ -162,6 +163,8 @@ export interface ScreenShareCaptureOptions {
     surfaceSwitching?: 'include' | 'exclude';
     /** specifies whether the browser should include the system audio among the possible audio sources offered to the user */
     systemAudio?: 'include' | 'exclude';
+    /** specify the type of content, see: https://www.w3.org/TR/mst-content-hint/#video-content-hints */
+    contentHint?: 'detail' | 'text' | 'motion';
     /**
      * Experimental option to control whether the audio playing in a tab will continue to be played out of a user's
      * local speakers when the tab is captured.
@@ -288,11 +291,13 @@ export declare const VideoPresets43: {
 };
 export declare const ScreenSharePresets: {
     readonly h360fps3: VideoPreset;
+    readonly h360fps15: VideoPreset;
     readonly h720fps5: VideoPreset;
     readonly h720fps15: VideoPreset;
     readonly h720fps30: VideoPreset;
     readonly h1080fps15: VideoPreset;
     readonly h1080fps30: VideoPreset;
+    readonly original: VideoPreset;
 };
 export {};
 //# sourceMappingURL=options.d.ts.map

package/dist/ts4.2/src/room/track/utils.d.ts

@@ -28,4 +28,5 @@ export declare function sourceToKind(source: Track.Source): MediaDeviceKind | un
 export declare function screenCaptureToDisplayMediaStreamOptions(options: ScreenShareCaptureOptions): DisplayMediaStreamOptions;
 export declare function mimeTypeToVideoCodecString(mimeType: string): "vp8" | "h264" | "vp9" | "av1";
 export declare function getTrackPublicationInfo<T extends TrackPublication>(tracks: T[]): TrackPublishedResponse[];
+export declare function getLogContextFromTrack(track: Track | TrackPublication): Record<string, unknown>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/src/room/types.d.ts

@@ -23,4 +23,8 @@ export type LiveKitReactNativeInfo = {
     devicePixelRatio: number;
 };
 export type SimulationScenario = 'signal-reconnect' | 'speaker' | 'node-failure' | 'server-leave' | 'migration' | 'resume-reconnect' | 'force-tcp' | 'force-tls' | 'full-reconnect' | 'subscriber-bandwidth';
+export type LoggerOptions = {
+    loggerName?: string;
+    loggerContextCb?: () => Record<string, unknown>;
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/ts4.2/src/room/utils.d.ts

@@ -20,6 +20,7 @@ export declare function isBrowserSupported(): boolean;
 export declare function isFireFox(): boolean;
 export declare function isChromiumBased(): boolean;
 export declare function isSafari(): boolean;
+export declare function isSafari17(): boolean;
 export declare function isMobile(): boolean;
 export declare function isWeb(): boolean;
 export declare function isReactNative(): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "1.15.6",
+  "version": "1.15.8",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -89,7 +89,7 @@
     "build:watch": "rollup --watch --config rollup.config.js",
     "build-docs": "typedoc",
     "proto": "protoc --es_out src/proto --es_opt target=ts -I./protocol ./protocol/livekit_rtc.proto ./protocol/livekit_models.proto",
-    "sample": "vite example -c vite.config.js",
+    "sample": "vite example -c vite.config.mjs",
     "lint": "eslint src",
     "test": "vitest run src",
     "deploy": "gh-pages -d example/dist",

package/src/api/SignalClient.ts

@@ -1,5 +1,5 @@
 import { protoInt64 } from '@bufbuild/protobuf';
-import log from '../logger';
+import log, { LoggerNames, getLogger } from '../logger';
 import {
   ClientInfo,
   DisconnectReason,
@@ -39,6 +39,7 @@ import {
 } from '../proto/livekit_rtc_pb';
 import { ConnectionError, ConnectionErrorReason } from '../room/errors';
 import CriticalTimers from '../room/timers';
+import type { LoggerOptions } from '../room/types';
 import { Mutex, getClientInfo, isReactNative, sleep, toWebsocketUrl } from '../room/utils';
 import { AsyncQueue } from '../utils/AsyncQueue';
 
@@ -172,7 +173,13 @@ export class SignalClient {
 
   private connectionLock: Mutex;
 
-  constructor(useJSON: boolean = false) {
+  private log = log;
+
+  private loggerContextCb?: LoggerOptions['loggerContextCb'];
+
+  constructor(useJSON: boolean = false, loggerOptions: LoggerOptions = {}) {
+    this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.Signal);
+    this.loggerContextCb = loggerOptions.loggerContextCb;
     this.useJSON = useJSON;
     this.requestQueue = new AsyncQueue();
     this.queuedRequests = [];
@@ -181,6 +188,10 @@ export class SignalClient {
     this.state = SignalConnectionState.DISCONNECTED;
   }
 
+  private get logContext() {
+    return this.loggerContextCb?.() ?? {};
+  }
+
   async join(
     url: string,
     token: string,
@@ -202,7 +213,10 @@ export class SignalClient {
     reason?: ReconnectReason,
   ): Promise<ReconnectResponse | void> {
     if (!this.options) {
-      log.warn('attempted to reconnect without signal options being set, ignoring');
+      this.log.warn(
+        'attempted to reconnect without signal options being set, ignoring',
+        this.logContext,
+      );
       return;
     }
     this.state = SignalConnectionState.RECONNECTING;
@@ -251,7 +265,7 @@ export class SignalClient {
           abortHandler();
         }
         abortSignal?.addEventListener('abort', abortHandler);
-        log.debug(`connecting to ${url + params}`);
+        this.log.debug(`connecting to ${url + params}`, this.logContext);
         if (this.ws) {
           await this.close();
         }
@@ -302,7 +316,10 @@ export class SignalClient {
           } else if (ev.data instanceof ArrayBuffer) {
             resp = SignalResponse.fromBinary(new Uint8Array(ev.data));
           } else {
-            log.error(`could not decode websocket message: ${typeof ev.data}`);
+            this.log.error(
+              `could not decode websocket message: ${typeof ev.data}`,
+              this.logContext,
+            );
             return;
           }
 
@@ -316,7 +333,8 @@ export class SignalClient {
               this.pingIntervalDuration = resp.message.value.pingInterval;
 
               if (this.pingTimeoutDuration && this.pingTimeoutDuration > 0) {
-                log.debug('ping config', {
+                this.log.debug('ping config', {
+                  ...this.logContext,
                   timeout: this.pingTimeoutDuration,
                   interval: this.pingIntervalDuration,
                 });
@@ -354,7 +372,7 @@ export class SignalClient {
         };
 
         this.ws.onclose = (ev: CloseEvent) => {
-          log.warn(`websocket closed`, { ev });
+          this.log.warn(`websocket closed`, { ...this.logContext, reason: ev.reason });
           this.handleOnClose(ev.reason);
         };
       } finally {
@@ -414,7 +432,7 @@ export class SignalClient {
 
   // initial offer after joining
   sendOffer(offer: RTCSessionDescriptionInit) {
-    log.debug('sending offer', offer);
+    this.log.debug('sending offer', { ...this.logContext, offerSdp: offer.sdp });
     this.sendRequest({
       case: 'offer',
       value: toProtoSessionDescription(offer),
@@ -423,7 +441,7 @@ export class SignalClient {
 
   // answer a server-initiated offer
   sendAnswer(answer: RTCSessionDescriptionInit) {
-    log.debug('sending answer');
+    this.log.debug('sending answer', { ...this.logContext, answerSdp: answer.sdp });
     return this.sendRequest({
       case: 'answer',
       value: toProtoSessionDescription(answer),
@@ -431,7 +449,7 @@ export class SignalClient {
   }
 
   sendIceCandidate(candidate: RTCIceCandidateInit, target: SignalTarget) {
-    log.trace('sending ice candidate', candidate);
+    this.log.trace('sending ice candidate', { ...this.logContext, candidate });
     return this.sendRequest({
       case: 'trickle',
       value: new TrickleRequest({
@@ -561,7 +579,10 @@ export class SignalClient {
       await sleep(this.signalLatency);
     }
     if (!this.ws || this.ws.readyState !== this.ws.OPEN) {
-      log.error(`cannot send signal request before connected, type: ${message?.case}`);
+      this.log.error(
+        `cannot send signal request before connected, type: ${message?.case}`,
+        this.logContext,
+      );
       return;
     }
     const req = new SignalRequest({ message });
@@ -573,14 +594,14 @@ export class SignalClient {
         this.ws.send(req.toBinary());
       }
     } catch (e) {
-      log.error('error sending signal message', { error: e });
+      this.log.error('error sending signal message', { ...this.logContext, error: e });
     }
   }
 
   private handleSignalResponse(res: SignalResponse) {
     const msg = res.message;
     if (msg == undefined) {
-      log.debug('received unsupported message');
+      this.log.debug('received unsupported message', this.logContext);
       return;
     }
 
@@ -658,7 +679,7 @@ export class SignalClient {
       this.resetPingTimeout();
       pingHandled = true;
     } else {
-      log.debug('unsupported message', msg);
+      this.log.debug('unsupported message', { ...this.logContext, msgCase: msg.case });
     }
 
     if (!pingHandled) {
@@ -679,14 +700,14 @@ export class SignalClient {
     if (this.state === SignalConnectionState.DISCONNECTED) return;
     const onCloseCallback = this.onClose;
     await this.close();
-    log.debug(`websocket connection closed: ${reason}`);
+    this.log.debug(`websocket connection closed: ${reason}`, { ...this.logContext, reason });
     if (onCloseCallback) {
       onCloseCallback(reason);
     }
   }
 
   private handleWSError(ev: Event) {
-    log.error('websocket error', ev);
+    this.log.error('websocket error', { ...this.logContext, error: ev });
   }
 
   /**
@@ -696,14 +717,15 @@ export class SignalClient {
   private resetPingTimeout() {
     this.clearPingTimeout();
     if (!this.pingTimeoutDuration) {
-      log.warn('ping timeout duration not set');
+      this.log.warn('ping timeout duration not set', this.logContext);
       return;
     }
     this.pingTimeout = CriticalTimers.setTimeout(() => {
-      log.warn(
+      this.log.warn(
         `ping timeout triggered. last pong received at: ${new Date(
           Date.now() - this.pingTimeoutDuration! * 1000,
         ).toUTCString()}`,
+        this.logContext,
       );
       this.handleOnClose('ping timeout');
     }, this.pingTimeoutDuration * 1000);
@@ -722,17 +744,17 @@ export class SignalClient {
     this.clearPingInterval();
     this.resetPingTimeout();
     if (!this.pingIntervalDuration) {
-      log.warn('ping interval duration not set');
+      this.log.warn('ping interval duration not set', this.logContext);
       return;
     }
-    log.debug('start ping interval');
+    this.log.debug('start ping interval', this.logContext);
     this.pingInterval = CriticalTimers.setInterval(() => {
       this.sendPing();
     }, this.pingIntervalDuration * 1000);
   }
 
   private clearPingInterval() {
-    log.debug('clearing ping interval');
+    this.log.debug('clearing ping interval', this.logContext);
     this.clearPingTimeout();
     if (this.pingInterval) {
       CriticalTimers.clearInterval(this.pingInterval);

package/src/index.ts

@@ -1,4 +1,4 @@
-import { LogLevel, setLogExtension, setLogLevel } from './logger';
+import { LogLevel, getLogger, setLogExtension, setLogLevel } from './logger';
 import { DataPacket_Kind, DisconnectReason, VideoQuality } from './proto/livekit_models_pb';
 import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
 import Room, { ConnectionState, RoomState } from './room/Room';
@@ -55,6 +55,7 @@ export {
   supportsVP9,
   createAudioAnalyser,
   LogLevel,
+  getLogger,
   Room,
   ConnectionState,
   RoomState,

package/src/logger.ts

@@ -9,9 +9,22 @@ export enum LogLevel {
   silent = 5,
 }
 
+export enum LoggerNames {
+  Default = 'livekit',
+  Room = 'livekit-room',
+  Participant = 'livekit-participant',
+  Track = 'livekit-track',
+  Publication = 'livekit-track-publication',
+  Engine = 'livekit-engine',
+  Signal = 'livekit-signal',
+  PCManager = 'livekit-pc-manager',
+  PCTransport = 'livekit-pc-transport',
+  E2EE = 'lk-e2ee',
+}
+
 type LogLevelString = keyof typeof LogLevel;
 
-type StructuredLogger = {
+export type StructuredLogger = {
   trace: (msg: string, context?: object) => void;
   debug: (msg: string, context?: object) => void;
   info: (msg: string, context?: object) => void;
@@ -20,17 +33,28 @@ type StructuredLogger = {
   setDefaultLevel: (level: log.LogLevelDesc) => void;
 };
 
-const livekitLogger = log.getLogger('livekit');
+let livekitLogger = log.getLogger('livekit');
 
 livekitLogger.setDefaultLevel(LogLevel.info);
 
 export default livekitLogger as StructuredLogger;
 
-export function setLogLevel(level: LogLevel | LogLevelString, loggerName?: 'livekit' | 'lk-e2ee') {
+/**
+ * @internal
+ */
+export function getLogger(name: string) {
+  const logger = log.getLogger(name);
+  logger.setDefaultLevel(livekitLogger.getLevel());
+  return logger as StructuredLogger;
+}
+
+export function setLogLevel(level: LogLevel | LogLevelString, loggerName?: LoggerNames) {
   if (loggerName) {
     log.getLogger(loggerName).setLevel(level);
   }
-  for (const logger of Object.values(log.getLoggers())) {
+  for (const logger of Object.entries(log.getLoggers())
+    .filter(([logrName]) => logrName.startsWith('livekit'))
+    .map(([, logr]) => logr)) {
     logger.setLevel(level);
   }
 }
@@ -41,10 +65,10 @@ export type LogExtension = (level: LogLevel, msg: string, context?: object) => v
  * use this to hook into the logging function to allow sending internal livekit logs to third party services
  * if set, the browser logs will lose their stacktrace information (see https://github.com/pimterry/loglevel#writing-plugins)
  */
-export function setLogExtension(extension: LogExtension) {
-  const originalFactory = livekitLogger.methodFactory;
+export function setLogExtension(extension: LogExtension, logger = livekitLogger) {
+  const originalFactory = logger.methodFactory;
 
-  livekitLogger.methodFactory = (methodName, configLevel, loggerName) => {
+  logger.methodFactory = (methodName, configLevel, loggerName) => {
     const rawMethod = originalFactory(methodName, configLevel, loggerName);
 
     const logLevel = LogLevel[methodName as LogLevelString];
@@ -58,7 +82,7 @@ export function setLogExtension(extension: LogExtension) {
       }
     };
   };
-  livekitLogger.setLevel(livekitLogger.getLevel()); // Be sure to call setLevel method in order to apply plugin
+  logger.setLevel(logger.getLevel()); // Be sure to call setLevel method in order to apply plugin
 }
 
 export const workerLogger = log.getLogger('lk-e2ee') as StructuredLogger;

package/src/options.ts

@@ -92,6 +92,8 @@ export interface InternalRoomOptions {
    * @experimental
    */
   e2ee?: E2EEOptions;
+
+  loggerName?: string;
 }
 
 /**

package/src/room/PCTransport.ts

@@ -2,8 +2,9 @@ import { EventEmitter } from 'events';
 import type { MediaDescription } from 'sdp-transform';
 import { parse, write } from 'sdp-transform';
 import { debounce } from 'ts-debounce';
-import log from '../logger';
+import log, { LoggerNames, getLogger } from '../logger';
 import { NegotiationError, UnexpectedConnectionState } from './errors';
+import type { LoggerOptions } from './types';
 import { ddExtensionURI, isChromiumBased, isSVCCodec } from './utils';
 
 /** @internal */
@@ -43,6 +44,10 @@ export default class PCTransport extends EventEmitter {
 
   private mediaConstraints: Record<string, unknown>;
 
+  private log = log;
+
+  private loggerOptions: LoggerOptions;
+
   pendingCandidates: RTCIceCandidateInit[] = [];
 
   restartingIce: boolean = false;
@@ -71,8 +76,14 @@ export default class PCTransport extends EventEmitter {
 
   onTrack?: (ev: RTCTrackEvent) => void;
 
-  constructor(config?: RTCConfiguration, mediaConstraints: Record<string, unknown> = {}) {
+  constructor(
+    config?: RTCConfiguration,
+    mediaConstraints: Record<string, unknown> = {},
+    loggerOptions: LoggerOptions = {},
+  ) {
     super();
+    this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.PCTransport);
+    this.loggerOptions = loggerOptions;
     this.config = config;
     this.mediaConstraints = mediaConstraints;
     this._pc = this.createPC();
@@ -112,6 +123,12 @@ export default class PCTransport extends EventEmitter {
     return pc;
   }
 
+  private get logContext() {
+    return {
+      ...this.loggerOptions.loggerContextCb?.(),
+    };
+  }
+
   get isICEConnected(): boolean {
     return (
       this._pc !== null &&
@@ -229,7 +246,7 @@ export default class PCTransport extends EventEmitter {
     }
 
     if (options?.iceRestart) {
-      log.debug('restarting ICE');
+      this.log.debug('restarting ICE', this.logContext);
       this.restartingIce = true;
     }
 
@@ -246,12 +263,12 @@ export default class PCTransport extends EventEmitter {
         return;
       }
     } else if (!this._pc || this._pc.signalingState === 'closed') {
-      log.warn('could not createOffer with closed peer connection');
+      this.log.warn('could not createOffer with closed peer connection', this.logContext);
       return;
     }
 
     // actually negotiate
-    log.debug('starting to negotiate');
+    this.log.debug('starting to negotiate', this.logContext);
     const offer = await this.pc.createOffer(options);
 
     const sdpParsed = parse(offer.sdp ?? '');
@@ -452,7 +469,10 @@ export default class PCTransport extends EventEmitter {
       const originalSdp = sd.sdp;
       sd.sdp = munged;
       try {
-        log.debug(`setting munged ${remote ? 'remote' : 'local'} description`);
+        this.log.debug(
+          `setting munged ${remote ? 'remote' : 'local'} description`,
+          this.logContext,
+        );
         if (remote) {
           await this.pc.setRemoteDescription(sd);
         } else {
@@ -460,7 +480,8 @@ export default class PCTransport extends EventEmitter {
         }
         return;
       } catch (e) {
-        log.warn(`not able to set ${sd.type}, falling back to unmodified sdp`, {
+        this.log.warn(`not able to set ${sd.type}, falling back to unmodified sdp`, {
+          ...this.logContext,
           error: e,
           sdp: munged,
         });
@@ -491,7 +512,7 @@ export default class PCTransport extends EventEmitter {
       if (!remote && this.pc.remoteDescription) {
         fields.remoteSdp = this.pc.remoteDescription;
       }
-      log.error(`unable to set ${sd.type}`, fields);
+      this.log.error(`unable to set ${sd.type}`, { ...this.logContext, fields });
       throw new NegotiationError(msg);
     }
   }