livekit-client 1.15.5 → 1.15.7

package/src/room/participant/publishUtils.ts

@@ -10,18 +10,20 @@ import type {
   VideoEncoding,
 } from '../track/options';
 import { ScreenSharePresets, VideoPreset, VideoPresets, VideoPresets43 } from '../track/options';
+import type { LoggerOptions } from '../types';
 import { getReactNativeOs, isFireFox, isReactNative, isSVCCodec } from '../utils';
 
 /** @internal */
 export function mediaTrackToLocalTrack(
   mediaStreamTrack: MediaStreamTrack,
   constraints?: MediaTrackConstraints,
+  loggerOptions?: LoggerOptions,
 ): LocalVideoTrack | LocalAudioTrack {
   switch (mediaStreamTrack.kind) {
     case 'audio':
-      return new LocalAudioTrack(mediaStreamTrack, constraints, false);
+      return new LocalAudioTrack(mediaStreamTrack, constraints, false, undefined, loggerOptions);
     case 'video':
-      return new LocalVideoTrack(mediaStreamTrack, constraints, false);
+      return new LocalVideoTrack(mediaStreamTrack, constraints, false, loggerOptions);
     default:
       throw new TrackInvalidError(`unsupported track type: ${mediaStreamTrack.kind}`);
   }
@@ -44,7 +46,7 @@ export const defaultSimulcastPresets43 = [VideoPresets43.h180, VideoPresets43.h3
 
 /* @internal */
 export const computeDefaultScreenShareSimulcastPresets = (fromPreset: VideoPreset) => {
-  const layers = [{ scaleResolutionDownBy: 2, fps: 3 }];
+  const layers = [{ scaleResolutionDownBy: 2, fps: fromPreset.encoding.maxFramerate }];
   return layers.map(
     (t) =>
       new VideoPreset(
@@ -54,7 +56,8 @@ export const computeDefaultScreenShareSimulcastPresets = (fromPreset: VideoPrese
           150_000,
           Math.floor(
             fromPreset.encoding.maxBitrate /
-              (t.scaleResolutionDownBy ** 2 * ((fromPreset.encoding.maxFramerate ?? 30) / t.fps)),
+              (t.scaleResolutionDownBy ** 2 *
+                ((fromPreset.encoding.maxFramerate ?? 30) / (t.fps ?? 30))),
           ),
         ),
         t.fps,

package/src/room/track/LocalAudioTrack.ts

@@ -1,7 +1,7 @@
-import log from '../../logger';
 import { TrackEvent } from '../events';
 import { computeBitrate, monitorFrequency } from '../stats';
 import type { AudioSenderStats } from '../stats';
+import type { LoggerOptions } from '../types';
 import { isWeb, unwrapConstraint } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';
@@ -28,8 +28,9 @@ export default class LocalAudioTrack extends LocalTrack {
     constraints?: MediaTrackConstraints,
     userProvidedTrack = true,
     audioContext?: AudioContext,
+    loggerOptions?: LoggerOptions,
   ) {
-    super(mediaTrack, Track.Kind.Audio, constraints, userProvidedTrack);
+    super(mediaTrack, Track.Kind.Audio, constraints, userProvidedTrack, loggerOptions);
     this.audioContext = audioContext;
     this.checkForSilence();
   }
@@ -52,7 +53,7 @@ export default class LocalAudioTrack extends LocalTrack {
     try {
       // disabled special handling as it will cause BT headsets to switch communication modes
       if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
-        log.debug('stopping mic track');
+        this.log.debug('stopping mic track', this.logContext);
         // also stop the track, so that microphone indicator is turned off
         this._mediaStreamTrack.stop();
       }
@@ -76,7 +77,7 @@ export default class LocalAudioTrack extends LocalTrack {
         (this.stopOnMute || this._mediaStreamTrack.readyState === 'ended' || deviceHasChanged) &&
         !this.isUserProvided
       ) {
-        log.debug('reacquiring mic track');
+        this.log.debug('reacquiring mic track', this.logContext);
         await this.restartTrack();
       }
       await super.unmute();
@@ -127,7 +128,7 @@ export default class LocalAudioTrack extends LocalTrack {
     try {
       stats = await this.getSenderStats();
     } catch (e) {
-      log.error('could not get audio sender stats', { error: e });
+      this.log.error('could not get audio sender stats', { ...this.logContext, error: e });
       return;
     }
 
@@ -158,7 +159,7 @@ export default class LocalAudioTrack extends LocalTrack {
         track: this._mediaStreamTrack,
         audioContext: this.audioContext,
       };
-      log.debug(`setting up audio processor ${processor.name}`);
+      this.log.debug(`setting up audio processor ${processor.name}`, this.logContext);
 
       await processor.init(processorOptions);
       this.processor = processor;
@@ -207,7 +208,7 @@ export default class LocalAudioTrack extends LocalTrack {
     const trackIsSilent = await detectSilence(this);
     if (trackIsSilent) {
       if (!this.isMuted) {
-        log.warn('silence detected on local audio track');
+        this.log.warn('silence detected on local audio track', this.logContext);
       }
       this.emit(TrackEvent.AudioSilenceDetected);
     }

package/src/room/track/LocalTrack.ts

@@ -1,9 +1,9 @@
 import { debounce } from 'ts-debounce';
-import log from '../../logger';
 import { getBrowser } from '../../utils/browserParser';
 import DeviceManager from '../DeviceManager';
 import { DeviceUnsupportedError, TrackInvalidError } from '../errors';
 import { TrackEvent } from '../events';
+import type { LoggerOptions } from '../types';
 import { Mutex, compareVersions, isMobile, sleep } from '../utils';
 import { Track, attachToElement, detachTrack } from './Track';
 import type { VideoCodec } from './options';
@@ -50,8 +50,9 @@ export default abstract class LocalTrack extends Track {
     kind: Track.Kind,
     constraints?: MediaTrackConstraints,
     userProvidedTrack = false,
+    loggerOptions?: LoggerOptions,
   ) {
-    super(mediaTrack, kind);
+    super(mediaTrack, kind, loggerOptions);
     this.reacquireTrack = false;
     this.providedByUser = userProvidedTrack;
     this.muteLock = new Mutex();
@@ -112,10 +113,6 @@ export default abstract class LocalTrack extends Track {
       this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
       this._mediaStreamTrack.removeEventListener('mute', this.handleTrackMuteEvent);
       this._mediaStreamTrack.removeEventListener('unmute', this.handleTrackUnmuteEvent);
-
-      if (!this.providedByUser && this._mediaStreamTrack !== newTrack) {
-        this._mediaStreamTrack.stop();
-      }
     }
 
     this.mediaStream = new MediaStream([newTrack]);
@@ -132,12 +129,14 @@ export default abstract class LocalTrack extends Track {
     }
     let processedTrack: MediaStreamTrack | undefined;
     if (this.processor && newTrack && this.processorElement) {
-      log.debug('restarting processor');
+      this.log.debug('restarting processor', this.logContext);
       if (this.kind === 'unknown') {
         throw TypeError('cannot set processor on track of unknown kind');
       }
 
       attachToElement(newTrack, this.processorElement);
+      // ensure the processorElement itself stays muted
+      this.processorElement.muted = true;
       await this.processor.restart({
         track: newTrack,
         kind: this.kind,
@@ -148,6 +147,11 @@ export default abstract class LocalTrack extends Track {
     if (this.sender) {
       await this.sender.replaceTrack(processedTrack ?? newTrack);
     }
+    // if `newTrack` is different from the existing track, stop the
+    // older track just before replacing it
+    if (!this.providedByUser && this._mediaStreamTrack !== newTrack) {
+      this._mediaStreamTrack.stop();
+    }
     this._mediaStreamTrack = newTrack;
     if (newTrack) {
       // sync muted state with the enabled state of the newly provided track
@@ -211,7 +215,7 @@ export default abstract class LocalTrack extends Track {
       throw new TrackInvalidError('unable to replace an unpublished track');
     }
 
-    log.debug('replace MediaStreamTrack');
+    this.log.debug('replace MediaStreamTrack', this.logContext);
     await this.setMediaStreamTrack(track);
     // this must be synced *after* setting mediaStreamTrack above, since it relies
     // on the previous state in order to cleanup
@@ -227,7 +231,7 @@ export default abstract class LocalTrack extends Track {
     if (!constraints) {
       constraints = this._constraints;
     }
-    log.debug('restarting track with constraints', constraints);
+    this.log.debug('restarting track with constraints', { ...this.logContext, constraints });
 
     const streamConstraints: MediaStreamConstraints = {
       audio: false,
@@ -255,7 +259,7 @@ export default abstract class LocalTrack extends Track {
     const mediaStream = await navigator.mediaDevices.getUserMedia(streamConstraints);
     const newTrack = mediaStream.getTracks()[0];
     newTrack.addEventListener('ended', this.handleEnded);
-    log.debug('re-acquired MediaStreamTrack');
+    this.log.debug('re-acquired MediaStreamTrack', this.logContext);
 
     await this.setMediaStreamTrack(newTrack);
     this._constraints = constraints;
@@ -265,7 +269,7 @@ export default abstract class LocalTrack extends Track {
   }
 
   protected setTrackMuted(muted: boolean) {
-    log.debug(`setting ${this.kind} track ${muted ? 'muted' : 'unmuted'}`);
+    this.log.debug(`setting ${this.kind} track ${muted ? 'muted' : 'unmuted'}`, this.logContext);
 
     if (this.isMuted === muted && this._mediaStreamTrack.enabled !== muted) {
       return;
@@ -288,10 +292,10 @@ export default abstract class LocalTrack extends Track {
   protected async handleAppVisibilityChanged() {
     await super.handleAppVisibilityChanged();
     if (!isMobile()) return;
-    log.debug(`visibility changed, is in Background: ${this.isInBackground}`);
+    this.log.debug(`visibility changed, is in Background: ${this.isInBackground}`, this.logContext);
 
     if (!this.isInBackground && this.needsReAcquisition && !this.isUserProvided && !this.isMuted) {
-      log.debug(`track needs to be reacquired, restarting ${this.source}`);
+      this.log.debug(`track needs to be reacquired, restarting ${this.source}`, this.logContext);
       await this.restart();
       this.reacquireTrack = false;
     }
@@ -299,7 +303,7 @@ export default abstract class LocalTrack extends Track {
 
   private handleTrackMuteEvent = () =>
     this.debouncedTrackMuteHandler().catch(() =>
-      log.debug('track mute bounce got cancelled by an unmute event'),
+      this.log.debug('track mute bounce got cancelled by an unmute event', this.logContext),
     );
 
   private debouncedTrackMuteHandler = debounce(async () => {
@@ -343,7 +347,7 @@ export default abstract class LocalTrack extends Track {
         return;
       }
       if (!this.sender) {
-        log.warn('unable to pause upstream for an unpublished track');
+        this.log.warn('unable to pause upstream for an unpublished track', this.logContext);
         return;
       }
 
@@ -367,7 +371,7 @@ export default abstract class LocalTrack extends Track {
         return;
       }
       if (!this.sender) {
-        log.warn('unable to resume upstream for an unpublished track');
+        this.log.warn('unable to resume upstream for an unpublished track', this.logContext);
         return;
       }
       this._isUpstreamPaused = false;
@@ -407,7 +411,7 @@ export default abstract class LocalTrack extends Track {
   async setProcessor(processor: TrackProcessor<this['kind']>, showProcessedStreamLocally = true) {
     const unlock = await this.processorLock.lock();
     try {
-      log.debug('setting up processor');
+      this.log.debug('setting up processor', this.logContext);
       if (this.processor) {
         await this.stopProcessor();
       }
@@ -415,12 +419,15 @@ export default abstract class LocalTrack extends Track {
         throw TypeError('cannot set processor on track of unknown kind');
       }
       this.processorElement = this.processorElement ?? document.createElement(this.kind);
-      this.processorElement.muted = true;
 
       attachToElement(this._mediaStreamTrack, this.processorElement);
+      this.processorElement.muted = true;
+
       this.processorElement
         .play()
-        .catch((error) => log.error('failed to play processor element', { error }));
+        .catch((error) =>
+          this.log.error('failed to play processor element', { ...this.logContext, error }),
+        );
 
       const processorOptions = {
         kind: this.kind,
@@ -458,7 +465,7 @@ export default abstract class LocalTrack extends Track {
   async stopProcessor() {
     if (!this.processor) return;
 
-    log.debug('stopping processor');
+    this.log.debug('stopping processor', this.logContext);
     this.processor.processedTrack?.stop();
     await this.processor.destroy();
     this.processor = undefined;

package/src/room/track/LocalTrackPublication.ts

@@ -1,5 +1,6 @@
 import type { TrackInfo } from '../../proto/livekit_models_pb';
 import { TrackEvent } from '../events';
+import type { LoggerOptions } from '../types';
 import type LocalAudioTrack from './LocalAudioTrack';
 import type LocalTrack from './LocalTrack';
 import type LocalVideoTrack from './LocalVideoTrack';
@@ -16,8 +17,8 @@ export default class LocalTrackPublication extends TrackPublication {
     return this.track?.isUpstreamPaused;
   }
 
-  constructor(kind: Track.Kind, ti: TrackInfo, track?: LocalTrack) {
-    super(kind, ti.sid, ti.name);
+  constructor(kind: Track.Kind, ti: TrackInfo, track?: LocalTrack, loggerOptions?: LoggerOptions) {
+    super(kind, ti.sid, ti.name, loggerOptions);
 
     this.updateInfo(ti);
     this.setTrack(track);

package/src/room/track/LocalVideoTrack.ts

@@ -1,10 +1,11 @@
 import type { SignalClient } from '../../api/SignalClient';
-import log from '../../logger';
+import type { StructuredLogger } from '../../logger';
 import { VideoLayer, VideoQuality } from '../../proto/livekit_models_pb';
 import { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc_pb';
 import { ScalabilityMode } from '../participant/publishUtils';
 import type { VideoSenderStats } from '../stats';
 import { computeBitrate, monitorFrequency } from '../stats';
+import type { LoggerOptions } from '../types';
 import { Mutex, isFireFox, isMobile, isWeb, unwrapConstraint } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';
@@ -58,8 +59,9 @@ export default class LocalVideoTrack extends LocalTrack {
     mediaTrack: MediaStreamTrack,
     constraints?: MediaTrackConstraints,
     userProvidedTrack = true,
+    loggerOptions?: LoggerOptions,
   ) {
-    super(mediaTrack, Track.Kind.Video, constraints, userProvidedTrack);
+    super(mediaTrack, Track.Kind.Video, constraints, userProvidedTrack, loggerOptions);
     this.senderLock = new Mutex();
   }
 
@@ -117,7 +119,7 @@ export default class LocalVideoTrack extends LocalTrack {
     const unlock = await this.muteLock.lock();
     try {
       if (this.source === Track.Source.Camera && !this.isUserProvided) {
-        log.debug('stopping camera track');
+        this.log.debug('stopping camera track', this.logContext);
         // also stop the track, so that camera indicator is turned off
         this._mediaStreamTrack.stop();
       }
@@ -132,7 +134,7 @@ export default class LocalVideoTrack extends LocalTrack {
     const unlock = await this.muteLock.lock();
     try {
       if (this.source === Track.Source.Camera && !this.isUserProvided) {
-        log.debug('reacquiring camera track');
+        this.log.debug('reacquiring camera track', this.logContext);
         await this.restartTrack();
       }
       await super.unmute();
@@ -202,7 +204,7 @@ export default class LocalVideoTrack extends LocalTrack {
         }),
       );
     }
-    log.debug(`setting publishing quality. max quality ${maxQuality}`);
+    this.log.debug(`setting publishing quality. max quality ${maxQuality}`, this.logContext);
     this.setPublishingLayers(qualities);
   }
 
@@ -288,7 +290,8 @@ export default class LocalVideoTrack extends LocalTrack {
    * been published
    */
   async setPublishingCodecs(codecs: SubscribedCodec[]): Promise<VideoCodec[]> {
-    log.debug('setting publishing codecs', {
+    this.log.debug('setting publishing codecs', {
+      ...this.logContext,
       codecs,
       currentCodec: this.codec,
     });
@@ -306,7 +309,10 @@ export default class LocalVideoTrack extends LocalTrack {
         await this.setPublishingLayers(codec.qualities);
       } else {
         const simulcastCodecInfo = this.simulcastCodecs.get(codec.codec as VideoCodec);
-        log.debug(`try setPublishingCodec for ${codec.codec}`, simulcastCodecInfo);
+        this.log.debug(`try setPublishingCodec for ${codec.codec}`, {
+          ...this.logContext,
+          simulcastCodecInfo,
+        });
         if (!simulcastCodecInfo || !simulcastCodecInfo.sender) {
           for (const q of codec.qualities) {
             if (q.enabled) {
@@ -315,12 +321,14 @@ export default class LocalVideoTrack extends LocalTrack {
             }
           }
         } else if (simulcastCodecInfo.encodings) {
-          log.debug(`try setPublishingLayersForSender ${codec.codec}`);
+          this.log.debug(`try setPublishingLayersForSender ${codec.codec}`, this.logContext);
           await setPublishingLayersForSender(
             simulcastCodecInfo.sender,
             simulcastCodecInfo.encodings!,
             codec.qualities,
             this.senderLock,
+            this.log,
+            this.logContext,
           );
         }
       }
@@ -333,12 +341,19 @@ export default class LocalVideoTrack extends LocalTrack {
    * Sets layers that should be publishing
    */
   async setPublishingLayers(qualities: SubscribedQuality[]) {
-    log.debug('setting publishing layers', qualities);
+    this.log.debug('setting publishing layers', { ...this.logContext, qualities });
     if (!this.sender || !this.encodings) {
       return;
     }
 
-    await setPublishingLayersForSender(this.sender, this.encodings, qualities, this.senderLock);
+    await setPublishingLayersForSender(
+      this.sender,
+      this.encodings,
+      qualities,
+      this.senderLock,
+      this.log,
+      this.logContext,
+    );
   }
 
   protected monitorSender = async () => {
@@ -351,7 +366,7 @@ export default class LocalVideoTrack extends LocalTrack {
     try {
       stats = await this.getSenderStats();
     } catch (e) {
-      log.error('could not get audio sender stats', { error: e });
+      this.log.error('could not get audio sender stats', { ...this.logContext, error: e });
       return;
     }
     const statsMap = new Map<string, VideoSenderStats>(stats.map((s) => [s.rid, s]));
@@ -382,9 +397,11 @@ async function setPublishingLayersForSender(
   senderEncodings: RTCRtpEncodingParameters[],
   qualities: SubscribedQuality[],
   senderLock: Mutex,
+  log: StructuredLogger,
+  logContext: Record<string, unknown>,
 ) {
   const unlock = await senderLock.lock();
-  log.debug('setPublishingLayersForSender', { sender, qualities, senderEncodings });
+  log.debug('setPublishingLayersForSender', { ...logContext, sender, qualities, senderEncodings });
   try {
     const params = sender.getParameters();
     const { encodings } = params;
@@ -458,6 +475,7 @@ async function setPublishingLayersForSender(
             `setting layer ${subscribedQuality.quality} to ${
               encoding.active ? 'enabled' : 'disabled'
             }`,
+            logContext,
           );
 
           // FireFox does not support setting encoding.active to false, so we
@@ -481,7 +499,7 @@ async function setPublishingLayersForSender(
 
     if (hasChanged) {
       params.encodings = encodings;
-      log.debug(`setting encodings`, params.encodings);
+      log.debug(`setting encodings`, { ...logContext, encodings: params.encodings });
       await sender.setParameters(params);
     }
   } finally {

package/src/room/track/RemoteAudioTrack.ts

@@ -1,7 +1,7 @@
-import log from '../../logger';
 import { TrackEvent } from '../events';
 import { computeBitrate } from '../stats';
 import type { AudioReceiverStats } from '../stats';
+import type { LoggerOptions } from '../types';
 import { isReactNative, supportsSetSinkId } from '../utils';
 import RemoteTrack from './RemoteTrack';
 import { Track } from './Track';
@@ -28,8 +28,9 @@ export default class RemoteAudioTrack extends RemoteTrack {
     receiver?: RTCRtpReceiver,
     audioContext?: AudioContext,
     audioOutput?: AudioOutputOptions,
+    loggerOptions?: LoggerOptions,
   ) {
-    super(mediaTrack, sid, Track.Kind.Audio, receiver);
+    super(mediaTrack, sid, Track.Kind.Audio, receiver, loggerOptions);
     this.audioContext = audioContext;
     this.webAudioPluginNodes = [];
     if (audioOutput) {
@@ -107,7 +108,7 @@ export default class RemoteAudioTrack extends RemoteTrack {
       element.setSinkId(this.sinkId);
     }
     if (this.audioContext && needsNewWebAudioConnection) {
-      log.debug('using audio context mapping');
+      this.log.debug('using audio context mapping', this.logContext);
       this.connectWebAudio(this.audioContext, element);
       element.volume = 0;
       element.muted = true;

package/src/room/track/RemoteTrack.ts

@@ -1,5 +1,6 @@
 import { TrackEvent } from '../events';
 import { monitorFrequency } from '../stats';
+import type { LoggerOptions } from '../types';
 import { Track } from './Track';
 
 export default abstract class RemoteTrack extends Track {
@@ -11,8 +12,10 @@ export default abstract class RemoteTrack extends Track {
     sid: string,
     kind: Track.Kind,
     receiver?: RTCRtpReceiver,
+    loggerOptions?: LoggerOptions,
   ) {
-    super(mediaTrack, kind);
+    super(mediaTrack, kind, loggerOptions);
+
     this.sid = sid;
     this.receiver = receiver;
   }

package/src/room/track/RemoteTrackPublication.ts

@@ -1,4 +1,3 @@
-import log from '../../logger';
 import {
   ParticipantTracks,
   SubscriptionError,
@@ -7,6 +6,7 @@ import {
 } from '../../proto/livekit_models_pb';
 import { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc_pb';
 import { TrackEvent } from '../events';
+import type { LoggerOptions } from '../types';
 import type RemoteTrack from './RemoteTrack';
 import RemoteVideoTrack from './RemoteVideoTrack';
 import { Track } from './Track';
@@ -31,8 +31,13 @@ export default class RemoteTrackPublication extends TrackPublication {
 
   protected subscriptionError?: SubscriptionError;
 
-  constructor(kind: Track.Kind, ti: TrackInfo, autoSubscribe: boolean | undefined) {
-    super(kind, ti.sid, ti.name);
+  constructor(
+    kind: Track.Kind,
+    ti: TrackInfo,
+    autoSubscribe: boolean | undefined,
+    loggerOptions?: LoggerOptions,
+  ) {
+    super(kind, ti.sid, ti.name, loggerOptions);
     this.subscribed = autoSubscribe;
     this.updateInfo(ti);
   }
@@ -252,13 +257,14 @@ export default class RemoteTrackPublication extends TrackPublication {
 
   private isManualOperationAllowed(): boolean {
     if (this.kind === Track.Kind.Video && this.isAdaptiveStream) {
-      log.warn('adaptive stream is enabled, cannot change video track settings', {
-        trackSid: this.trackSid,
-      });
+      this.log.warn(
+        'adaptive stream is enabled, cannot change video track settings',
+        this.logContext,
+      );
       return false;
     }
     if (!this.isDesired) {
-      log.warn('cannot update track settings when not subscribed', { trackSid: this.trackSid });
+      this.log.warn('cannot update track settings when not subscribed', this.logContext);
       return false;
     }
     return true;
@@ -274,17 +280,19 @@ export default class RemoteTrackPublication extends TrackPublication {
   }
 
   protected handleVisibilityChange = (visible: boolean) => {
-    log.debug(`adaptivestream video visibility ${this.trackSid}, visible=${visible}`, {
-      trackSid: this.trackSid,
-    });
+    this.log.debug(
+      `adaptivestream video visibility ${this.trackSid}, visible=${visible}`,
+      this.logContext,
+    );
     this.disabled = !visible;
     this.emitTrackUpdate();
   };
 
   protected handleVideoDimensionsChange = (dimensions: Track.Dimensions) => {
-    log.debug(`adaptivestream video dimensions ${dimensions.width}x${dimensions.height}`, {
-      trackSid: this.trackSid,
-    });
+    this.log.debug(
+      `adaptivestream video dimensions ${dimensions.width}x${dimensions.height}`,
+      this.logContext,
+    );
     this.videoDimensions = dimensions;
     this.emitTrackUpdate();
   };

package/src/room/track/RemoteVideoTrack.ts

@@ -1,9 +1,9 @@
 import { debounce } from 'ts-debounce';
-import log from '../../logger';
 import { TrackEvent } from '../events';
 import type { VideoReceiverStats } from '../stats';
 import { computeBitrate } from '../stats';
 import CriticalTimers from '../timers';
+import type { LoggerOptions } from '../types';
 import type { ObservableMediaElement } from '../utils';
 import { getDevicePixelRatio, getIntersectionObserver, getResizeObserver, isWeb } from '../utils';
 import RemoteTrack from './RemoteTrack';
@@ -28,8 +28,9 @@ export default class RemoteVideoTrack extends RemoteTrack {
     sid: string,
     receiver?: RTCRtpReceiver,
     adaptiveStreamSettings?: AdaptiveStreamSettings,
+    loggerOptions?: LoggerOptions,
   ) {
-    super(mediaTrack, sid, Track.Kind.Video, receiver);
+    super(mediaTrack, sid, Track.Kind.Video, receiver, loggerOptions);
     this.adaptiveStreamSettings = adaptiveStreamSettings;
   }
 
@@ -103,7 +104,7 @@ export default class RemoteVideoTrack extends RemoteTrack {
       this.debouncedHandleResize();
       this.updateVisibility();
     } else {
-      log.warn('visibility resize observer not triggered');
+      this.log.warn('visibility resize observer not triggered', this.logContext);
     }
   }
 
@@ -114,7 +115,7 @@ export default class RemoteVideoTrack extends RemoteTrack {
    */
   stopObservingElementInfo(elementInfo: ElementInfo) {
     if (!this.isAdaptiveStream) {
-      log.warn('stopObservingElementInfo ignored');
+      this.log.warn('stopObservingElementInfo ignored', this.logContext);
       return;
     }
     const stopElementInfos = this.elementInfos.filter((info) => info === elementInfo);

package/src/room/track/Track.ts

@@ -1,11 +1,13 @@
 import { EventEmitter } from 'events';
 import type TypedEventEmitter from 'typed-emitter';
 import type { SignalClient } from '../../api/SignalClient';
-import log from '../../logger';
+import log, { LoggerNames, StructuredLogger, getLogger } from '../../logger';
 import { TrackSource, TrackType } from '../../proto/livekit_models_pb';
 import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc_pb';
 import { TrackEvent } from '../events';
+import type { LoggerOptions } from '../types';
 import { isFireFox, isSafari, isWeb } from '../utils';
+import { getLogContextFromTrack } from './utils';
 
 const BACKGROUND_REACTION_DELAY = 5000;
 
@@ -46,12 +48,23 @@ export abstract class Track extends (EventEmitter as new () => TypedEventEmitter
 
   private backgroundTimeout: ReturnType<typeof setTimeout> | undefined;
 
+  private loggerContextCb: LoggerOptions['loggerContextCb'];
+
   protected _currentBitrate: number = 0;
 
   protected monitorInterval?: ReturnType<typeof setInterval>;
 
-  protected constructor(mediaTrack: MediaStreamTrack, kind: Track.Kind) {
+  protected log: StructuredLogger = log;
+
+  protected constructor(
+    mediaTrack: MediaStreamTrack,
+    kind: Track.Kind,
+    loggerOptions: LoggerOptions = {},
+  ) {
     super();
+    this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.Track);
+    this.loggerContextCb = loggerOptions.loggerContextCb;
+
     this.setMaxListeners(100);
     this.kind = kind;
     this._mediaStreamTrack = mediaTrack;
@@ -59,6 +72,13 @@ export abstract class Track extends (EventEmitter as new () => TypedEventEmitter
     this.source = Track.Source.Unknown;
   }
 
+  protected get logContext() {
+    return {
+      ...this.loggerContextCb?.(),
+      ...getLogContextFromTrack(this),
+    };
+  }
+
   /** current receive bits per second */
   get currentBitrate(): number {
     return this._currentBitrate;
@@ -224,6 +244,16 @@ export abstract class Track extends (EventEmitter as new () => TypedEventEmitter
     }
   }
 
+  /** @internal */
+  updateLoggerOptions(loggerOptions: LoggerOptions) {
+    if (loggerOptions.loggerName) {
+      this.log = getLogger(loggerOptions.loggerName);
+    }
+    if (loggerOptions.loggerContextCb) {
+      this.loggerContextCb = loggerOptions.loggerContextCb;
+    }
+  }
+
   private recycleElement(element: HTMLMediaElement) {
     if (element instanceof HTMLAudioElement) {
       // we only need to re-use a single element