livekit-client 2.20.1 → 2.21.0

package/src/api/SignalClient.e2e.test.ts

@@ -0,0 +1,264 @@
+import { type LeaveRequest, LeaveRequest_Action } from '@livekit/protocol';
+import { afterEach, beforeEach, describe, expect, inject, it, vi } from 'vitest';
+import { ConnectionErrorReason } from '../room/errors';
+import { createInvalidToken, createToken } from '../test/signalToken';
+import { SignalClient, SignalConnectionState, type SignalOptions } from './SignalClient';
+
+// Provided by src/test/signalServerSetup.ts (spawns the livekit-server test-server).
+const serverUrl = inject('serverUrl');
+const unavailable = inject('e2eUnavailable');
+
+const defaultOpts = (): SignalOptions => ({
+  autoSubscribe: true,
+  maxRetries: 0,
+  e2eeEnabled: false,
+  websocketTimeout: 5_000,
+});
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T> {
+  return Promise.race([
+    p,
+    new Promise<T>((_, reject) =>
+      setTimeout(() => reject(new Error(`timed out waiting for ${label}`)), ms),
+    ),
+  ]);
+}
+
+/** Resolves with the reason passed to onClose (register before the event can fire). */
+function captureClose(client: SignalClient): Promise<string> {
+  return new Promise((resolve) => {
+    client.onClose = (reason) => resolve(reason);
+  });
+}
+
+/** Resolves with the LeaveRequest passed to onLeave. */
+function captureLeave(client: SignalClient): Promise<LeaveRequest> {
+  return new Promise((resolve) => {
+    client.onLeave = (leave) => resolve(leave);
+  });
+}
+
+describe.skipIf(!!unavailable)('SignalClient e2e', () => {
+  // Behaviors that depend on the signal path (v0 legacy vs v1).
+  describe.each([
+    { label: 'v0', useV0: true },
+    { label: 'v1', useV0: false },
+  ])('$label path', ({ useV0 }) => {
+    let client: SignalClient;
+
+    beforeEach(() => {
+      client = new SignalClient(false);
+    });
+
+    afterEach(async () => {
+      await client.close().catch(() => {});
+    });
+
+    /** Mint a token whose metadata selects the server behavior mode, then join. */
+    const join = (mode: string, opts: SignalOptions = defaultOpts(), abortSignal?: AbortSignal) =>
+      createToken({ signal: mode }).then((token) =>
+        client.join(serverUrl, token, opts, abortSignal, useV0),
+      );
+
+    it('connects and reports CONNECTED with a join response', async () => {
+      const res = await join('happy');
+      expect(res).toBeTruthy();
+      expect(res.pingInterval).toBeGreaterThan(0);
+      expect(client.currentState).toBe(SignalConnectionState.CONNECTED);
+    });
+
+    it('stays connected past the ping timeout while the server pongs', async () => {
+      const onClose = vi.fn();
+      await join('happy');
+      client.onClose = onClose;
+      // Server ping timeout is 3s; a healthy pong loop must keep us alive.
+      await sleep(4_000);
+      expect(onClose).not.toHaveBeenCalled();
+      expect(client.currentState).toBe(SignalConnectionState.CONNECTED);
+    });
+
+    it('closes with a ping timeout when the server stops ponging', async () => {
+      const closed = captureClose(client);
+      await join('no_pong');
+      expect(client.currentState).toBe(SignalConnectionState.CONNECTED);
+      const reason = await withTimeout(closed, 8_000, 'onClose (ping timeout)');
+      expect(reason).toContain('ping timeout');
+      expect(client.currentState).toBe(SignalConnectionState.DISCONNECTED);
+    });
+
+    it('surfaces an unexpected transport close while connected', async () => {
+      const closed = captureClose(client);
+      await join('close_when_connected');
+      const reason = await withTimeout(closed, 5_000, 'onClose (transport closed)');
+      expect(reason).toBeTruthy();
+      expect(client.currentState).toBe(SignalConnectionState.DISCONNECTED);
+    });
+
+    it('surfaces an abnormal socket drop (1006) while connected', async () => {
+      // Server sends the join, then drops the TCP connection with no close
+      // handshake -> the browser reports an abnormal 1006 closure, exercising
+      // WebSocketStream's error->close path (distinct from the clean 1011 above).
+      const closed = captureClose(client);
+      await join('drop_when_connected');
+      expect(client.currentState).toBe(SignalConnectionState.CONNECTED);
+      const reason = await withTimeout(closed, 5_000, 'onClose (abnormal drop)');
+
+      expect(reason).toBe('Unexpected WS error');
+      expect(client.currentState).toBe(SignalConnectionState.DISCONNECTED);
+    });
+
+    it('rejects the join when the socket closes before the first message', async () => {
+      // Upgrade succeeds, then the server closes the WS before sending a join.
+      // The client is still establishing, so it rejects rather than hanging.
+      const err = await join('close_before_join').then(
+        () => undefined,
+        (e) => e as Error,
+      );
+      expect(err).toBeInstanceOf(Error);
+      expect((err as { reason?: ConnectionErrorReason }).reason).toBe(
+        ConnectionErrorReason.InternalError,
+      );
+    });
+
+    it('delivers a server-initiated leave while connected', async () => {
+      const left = captureLeave(client);
+      await join('leave_when_connected');
+      const leave = await withTimeout(left, 5_000, 'onLeave');
+      expect(leave).toBeTruthy();
+      expect(leave.action).toBe(LeaveRequest_Action.DISCONNECT);
+    });
+
+    it('forwards a non-DISCONNECT leave action verbatim', async () => {
+      // SignalClient does not branch on the leave action (RTCEngine does); it
+      // must pass it through unchanged. Guards the FSM swap's leave_received
+      // effect, which carries leaveAction. Uses RECONNECT to prove it's not
+      // defaulted to DISCONNECT.
+      const left = captureLeave(client);
+      const token = await createToken({
+        signal: 'leave_when_connected',
+        leaveAction: LeaveRequest_Action.RECONNECT,
+      });
+      await client.join(serverUrl, token, defaultOpts(), undefined, useV0);
+      const leave = await withTimeout(left, 5_000, 'onLeave');
+      expect(leave.action).toBe(LeaveRequest_Action.RECONNECT);
+    });
+
+    it('rejects the join when a leave arrives as the first message', async () => {
+      const err = await join('leave_first_message').then(
+        () => undefined,
+        (e) => e as Error,
+      );
+      expect(err).toBeInstanceOf(Error);
+    });
+
+    it('closes gracefully via close() without firing onClose', async () => {
+      const onClose = vi.fn();
+      await join('happy');
+      client.onClose = onClose;
+      await client.close();
+      expect(client.isDisconnected).toBe(true);
+      expect(onClose).not.toHaveBeenCalled();
+    });
+
+    it('reconnects (resume) back to CONNECTED', async () => {
+      await join('happy');
+      const token = await createToken({ signal: 'happy' });
+      await client.reconnect(serverUrl, token, 'RM_session');
+      expect(client.currentState).toBe(SignalConnectionState.CONNECTED);
+    });
+
+    it('rejects a reconnect when a leave arrives as the first message', async () => {
+      // Reconnecting into a room that sends leave-first exercises the client's
+      // first-message validation while in RECONNECTING (path-independent: it
+      // doesn't rely on the mock detecting reconnect, which v1 hides inside the
+      // gzipped join_request the mock ignores).
+      await join('happy');
+      const token = await createToken({ signal: 'leave_first_message' });
+      const err = await client.reconnect(serverUrl, token, 'RM_session').then(
+        () => undefined,
+        (e) => e as Error,
+      );
+      expect(err).toBeInstanceOf(Error);
+    });
+
+    // --- validate-endpoint classification -------------------------------
+    it('classifies an invalid token as NotAllowed', async () => {
+      const token = await createInvalidToken();
+      const err = await client
+        .join(serverUrl, token, defaultOpts(), undefined, useV0)
+        .catch((e) => e);
+      expect(err.reason).toBe(ConnectionErrorReason.NotAllowed);
+    });
+
+    it('classifies room-not-found as NotAllowed', async () => {
+      const err = await join('room_not_found').catch((e) => e);
+      expect(err.reason).toBe(ConnectionErrorReason.NotAllowed);
+    });
+
+    it('classifies a wrong-path 404 as ServiceNotFound', async () => {
+      const err = await join('validate_service_not_found').catch((e) => e);
+      expect(err.reason).toBe(ConnectionErrorReason.ServiceNotFound);
+    });
+
+    it('surfaces a 5xx validate as a WebSocket error (ws error shadows 5xx→internal)', async () => {
+      // Current behavior: handleConnectionError only maps a 5xx to InternalError
+      // when the ws rejection is NOT a ConnectionError. WebSocketStream always
+      // rejects with one, so for a refused upgrade the WS error wins. Only
+      // 401/403/404 (handled before that check) override it.
+      const err = await join('validate_500').catch((e) => e);
+      expect(err.reason).toBe(ConnectionErrorReason.WebSocket);
+    });
+  });
+
+  // Path-independent transport-level failures (run once, via v0).
+  describe('transport failures', () => {
+    let client: SignalClient;
+
+    beforeEach(() => {
+      client = new SignalClient(false);
+    });
+
+    afterEach(async () => {
+      await client.close().catch(() => {});
+    });
+
+    it('classifies an unreachable server as ServerUnreachable', async () => {
+      const token = await createToken({ signal: 'happy' });
+      // Nothing listening on this port -> ws fails, validate fetch fails.
+      const err = await client
+        .join('ws://127.0.0.1:59999', token, defaultOpts(), undefined, true)
+        .catch((e) => e);
+      expect(err.reason).toBe(ConnectionErrorReason.ServerUnreachable);
+    });
+
+    it('cancels the connect when the AbortSignal fires mid-connection', async () => {
+      const controller = new AbortController();
+      const token = await createToken({ signal: 'no_first_message' });
+      const p = client.join(serverUrl, token, defaultOpts(), controller.signal, true);
+      setTimeout(() => controller.abort('user requested abort'), 300);
+      const err = await p.catch((e) => e);
+      expect(err.reason).toBe(ConnectionErrorReason.Cancelled);
+    });
+
+    it('times out when the socket opens but no first message arrives', async () => {
+      // wsTimeout only guards the WebSocket upgrade and is cleared once ws.opened
+      // resolves. If the server accepts the socket then stays silent, the wait for
+      // the first message is guarded by its own JOIN_RESPONSE_TIMEOUT (5s), so
+      // join() rejects with Timeout instead of hanging.
+      const token = await createToken({ signal: 'no_first_message' });
+      const joinPromise = client.join(serverUrl, token, defaultOpts(), undefined, true);
+
+      const err = await withTimeout(
+        joinPromise.then(
+          () => undefined,
+          (e) => e,
+        ),
+        8_000,
+        'join to time out',
+      );
+      expect(err.reason).toBe(ConnectionErrorReason.Timeout);
+    });
+  });
+});

package/src/api/SignalClient.ts

@@ -121,6 +121,11 @@ export enum SignalConnectionState {
 /** specifies how much time (in ms) we allow for the ws to close its connection gracefully before continuing */
 const MAX_WS_CLOSE_TIME = 250;
 
+/**
+ * How long (in ms) to wait for the first message after the WebSocket upgrade.
+ */
+const JOIN_RESPONSE_TIMEOUT = 5_000;
+
 /** @internal */
 export class SignalClient {
   requestQueue: AsyncQueue;
@@ -408,7 +413,7 @@ export class SignalClient {
                   state: this.state,
                 });
                 if (this.state === SignalConnectionState.CONNECTED) {
-                  this.handleOnClose(closeInfo.reason ?? 'Unexpected WS error');
+                  this.handleOnClose(closeInfo.reason || 'Unexpected WS error');
                 }
               }
               return;
@@ -441,7 +446,34 @@ export class SignalClient {
           }
           const signalReader = connection.readable.getReader();
           this.streamWriter = connection.writable.getWriter();
-          const firstMessage = await signalReader.read();
+
+          // wsTimeout only guarded the upgrade; guard the first-message read with
+          // its own timeout so a silent server can't hang join() forever.
+          let firstMessage: ReadableStreamReadResult<string | ArrayBuffer>;
+          let firstMessageTimeout: ReturnType<typeof setTimeout> | undefined;
+          try {
+            firstMessage = await Promise.race([
+              signalReader.read(),
+              new Promise<never>((_, rejectRead) => {
+                firstMessageTimeout = setTimeout(() => {
+                  rejectRead(
+                    ConnectionError.timeout(
+                      'signal connection timed out while waiting for the first message',
+                    ),
+                  );
+                }, JOIN_RESPONSE_TIMEOUT);
+              }),
+            ]);
+          } catch (e) {
+            // No first message in time: release the reader and tear down the ws
+            // so we surface the timeout instead of leaking an open connection.
+            signalReader.releaseLock();
+            reject(e);
+            this.close();
+            return;
+          } finally {
+            clearTimeout(firstMessageTimeout);
+          }
           signalReader.releaseLock();
           if (!firstMessage.value) {
             throw ConnectionError.internal('no message received as first message');

package/src/index.ts

@@ -104,6 +104,8 @@ export type {
   TranscriptionSegment,
   ChatMessage,
   SendTextOptions,
+  SendBytesOptions,
+  ByteStreamInfo,
 } from './room/types';
 export * from './version';
 export {

package/src/logger.ts

@@ -22,6 +22,8 @@ export enum LoggerNames {
   PCTransport = 'livekit-pc-transport',
   E2EE = 'lk-e2ee',
   DataTracks = 'livekit-data-tracks',
+  Region = 'livekit-region',
+  ICE = 'livekit-ice',
 }
 
 type LogLevelString = keyof typeof LogLevel;

package/src/room/PCTransport.ts

@@ -15,15 +15,24 @@ interface TrackBitrateInfo {
   transceiver?: RTCRtpTransceiver;
   codec: string;
   maxbr: number;
+  isScreenShare?: boolean;
 }
 
-/* The svc codec (av1/vp9) would use a very low bitrate at the begining and
-increase slowly by the bandwidth estimator until it reach the target bitrate. The
-process commonly cost more than 10 seconds cause subscriber will get blur video at
-the first few seconds. So we use a 70% of target bitrate here as the start bitrate to
-eliminate this issue.
-*/
-const startBitrateForSVC = 0.7;
+/*
+ * Video codecs use a very low bitrate at the beginning and increase slowly by
+ * the bandwidth estimator until they reach the target bitrate. The process commonly
+ * costs more than 10 seconds causing subscribers to get blurry video at the first
+ * few seconds. We use x-google-start-bitrate to hint the BWE to start higher.
+ *
+ * Why 90%: Gives ~10% headroom for bandwidth estimation while starting close to target.
+ * Why same for all codecs: Target bitrate already accounts for codec efficiency
+ * (e.g., users set lower targets for VP9/AV1 knowing they're more efficient).
+ * Why cap at 1 Mbps: Prevents BWE from starting too aggressively on high bitrate tracks.
+ */
+const startBitrateMultiplier = 0.9;
+
+/** Maximum x-google-start-bitrate in kbps. 1 Mbps prevents BWE from starting too aggressively. */
+const maxStartBitrateKbps = 1000;
 
 const debounceInterval = 20;
 
@@ -53,6 +62,8 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
 
   private log = log;
 
+  private iceLog = log;
+
   private loggerOptions: LoggerOptions;
 
   private ddExtID = 0;
@@ -95,8 +106,12 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
 
   constructor(config?: RTCConfiguration, loggerOptions: LoggerOptions = {}) {
     super();
-    this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.PCTransport);
     this.loggerOptions = loggerOptions;
+    this.log = getLogger(
+      loggerOptions.loggerName ?? LoggerNames.PCTransport,
+      () => this.logContext,
+    );
+    this.iceLog = getLogger(LoggerNames.ICE, () => this.logContext);
     this.config = config;
     this._pc = this.createPC();
     this.offerLock = new Mutex();
@@ -107,24 +122,33 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
 
     pc.onicecandidate = (ev) => {
       if (!ev.candidate) return;
+      this.iceLog.debug('local ICE candidate gathered', { candidate: ev.candidate.candidate });
       this.onIceCandidate?.(ev.candidate);
     };
     pc.onicecandidateerror = (ev) => {
+      this.iceLog.debug('ICE candidate error', { event: ev });
       this.onIceCandidateError?.(ev);
     };
 
     pc.oniceconnectionstatechange = () => {
+      this.iceLog.debug(`ICE connection state: ${pc.iceConnectionState}`);
       this.onIceConnectionStateChange?.(pc.iceConnectionState);
     };
 
     pc.onsignalingstatechange = () => {
+      this.log.debug(`signaling state: ${pc.signalingState}`);
       this.onSignalingStatechange?.(pc.signalingState);
     };
 
     pc.onconnectionstatechange = () => {
+      this.log.debug(`connection state: ${pc.connectionState}`);
       this.onConnectionStateChange?.(pc.connectionState);
     };
     pc.ondatachannel = (ev) => {
+      this.log.debug('data channel opened by peer', {
+        label: ev.channel.label,
+        id: ev.channel.id,
+      });
       this.onDataChannel?.(ev);
     };
     pc.ontrack = (ev) => {
@@ -150,6 +174,9 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
     if (this.pc.remoteDescription && !this.restartingIce) {
       return this.pc.addIceCandidate(candidate);
     }
+    this.iceLog.debug('queuing remote ICE candidate until remote description applied', {
+      pendingCount: this.pendingCandidates.length + 1,
+    });
     this.pendingCandidates.push(candidate);
   }
 
@@ -161,7 +188,6 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
       offerId !== this.latestOfferId
     ) {
       this.log.warn('ignoring answer for old offer', {
-        ...this.logContext,
         offerId,
         latestOfferId: this.latestOfferId,
       });
@@ -180,7 +206,7 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
         sdpParsed.media.forEach((media) => {
           ensureIPAddrMatchVersion(media);
         });
-        this.log.debug('setting pending initial offer before processing answer', this.logContext);
+        this.log.debug('setting pending initial offer before processing answer');
         await this.setMungedSDP(initialOffer, write(sdpParsed));
       }
       const sdpParsed = parse(sd.sdp ?? '');
@@ -249,6 +275,11 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
     }
     await this.setMungedSDP(sd, mungedSDP, true);
 
+    if (this.pendingCandidates.length > 0) {
+      this.iceLog.debug('flushing queued ICE candidates', {
+        count: this.pendingCandidates.length,
+      });
+    }
     this.pendingCandidates.forEach((candidate) => {
       this.pc.addIceCandidate(candidate);
     });
@@ -298,10 +329,7 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
     const unlock = await this.offerLock.lock();
     try {
       if (this.pc.signalingState !== 'stable') {
-        this.log.warn(
-          'signaling state is not stable, cannot create initial offer',
-          this.logContext,
-        );
+        this.log.warn('signaling state is not stable, cannot create initial offer');
         return;
       }
       const offerId = this.latestOfferId + 1;
@@ -328,7 +356,7 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
       }
 
       if (options?.iceRestart) {
-        this.log.debug('restarting ICE', this.logContext);
+        this.iceLog.debug('restarting ICE');
         this.restartingIce = true;
       }
 
@@ -345,21 +373,21 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
           await this._pc.setRemoteDescription(currentSD);
         } else {
           this.renegotiate = true;
-          this.log.debug('requesting renegotiation', { ...this.logContext });
+          this.log.debug('requesting renegotiation');
           return;
         }
       } else if (!this._pc || this._pc.signalingState === 'closed') {
-        this.log.warn('could not createOffer with closed peer connection', this.logContext);
+        this.log.warn('could not createOffer with closed peer connection');
         return;
       }
 
       // actually negotiate
-      this.log.debug('starting to negotiate', this.logContext);
+      this.log.debug('starting to negotiate');
       // increase the offer id at the start to ensure the offer is always > 0 so that we can use 0 as a default value for legacy behavior
       const offerId = this.latestOfferId + 1;
       this.latestOfferId = offerId;
       const offer = await this.pc.createOffer(options);
-      this.log.debug('original offer', { sdp: offer.sdp, ...this.logContext });
+      this.log.debug('original offer', { sdp: offer.sdp });
 
       const sdpParsed = parse(offer.sdp ?? '');
       sdpParsed.media.forEach((media) => {
@@ -390,14 +418,18 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
             }
 
             // mung sdp for bitrate setting that can't apply by sendEncoding
-            if (!isSVCCodec(trackbr.codec)) {
-              return true;
-            }
-
-            const startBitrate = Math.round(trackbr.maxbr * startBitrateForSVC);
+            // Use 90% of target bitrate, capped at 1 Mbps for camera to prevent BWE from starting too aggressively
+            // Screen share is not capped since text/UI clarity requires high bitrate from the start
+            // TODO: dynamically adjust start bitrate based on network conditions (e.g., use previous BWE estimate)
+            const calculatedStartBitrate = Math.round(trackbr.maxbr * startBitrateMultiplier);
+            const startBitrate = trackbr.isScreenShare
+              ? calculatedStartBitrate
+              : Math.min(calculatedStartBitrate, maxStartBitrateKbps);
 
+            let fmtpFound = false;
             for (const fmtp of media.fmtp) {
               if (fmtp.payload === codecPayload) {
+                fmtpFound = true;
                 // if another track's fmtp already is set, we cannot override the bitrate
                 // this has the unfortunate consequence of being forced to use the
                 // initial track's bitrate for all tracks
@@ -407,6 +439,13 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
                 break;
               }
             }
+            // VP8 and some codecs may not have an existing fmtp line - create one
+            if (!fmtpFound) {
+              media.fmtp.push({
+                payload: codecPayload,
+                config: `x-google-start-bitrate=${startBitrate}`,
+              });
+            }
             return true;
           });
         }
@@ -424,7 +463,6 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
       }
       if (this.latestOfferId > offerId) {
         this.log.warn('latestOfferId mismatch', {
-          ...this.logContext,
           latestOfferId: this.latestOfferId,
           offerId,
         });
@@ -576,6 +614,7 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
     if (!this._pc) {
       return;
     }
+    this.log.debug('closing peer connection');
     this.pendingInitialOffer = undefined;
     this._pc.close();
     this._pc.onconnectionstatechange = null;
@@ -597,10 +636,7 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
     if (munged) {
       sd.sdp = munged;
       try {
-        this.log.debug(
-          `setting munged ${remote ? 'remote' : 'local'} description`,
-          this.logContext,
-        );
+        this.log.debug(`setting munged ${remote ? 'remote' : 'local'} description`);
         if (remote) {
           await this.pc.setRemoteDescription(sd);
         } else {
@@ -609,7 +645,6 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
         return;
       } catch (e) {
         this.log.warn(`not able to set ${sd.type}, falling back to unmodified sdp`, {
-          ...this.logContext,
           error: e,
           mungedSdp: munged,
           originalSdp,
@@ -642,7 +677,7 @@ export default class PCTransport extends (EventEmitter as new () => TypedEmitter
       if (!remote && this.pc.remoteDescription) {
         fields.remoteSdp = this.pc.remoteDescription;
       }
-      this.log.error(`unable to set ${sd.type}`, { ...this.logContext, fields });
+      this.log.error(`unable to set ${sd.type}`, { fields });
       throw new NegotiationError(msg);
     }
   }

package/src/room/PCTransportManager.ts

@@ -65,6 +65,8 @@ export class PCTransportManager {
 
   private log = log;
 
+  private iceLog = log;
+
   private loggerOptions: LoggerOptions;
 
   private _mode: PCMode;
@@ -74,8 +76,9 @@ export class PCTransportManager {
   }
 
   constructor(mode: PCMode, loggerOptions: LoggerOptions, rtcConfig?: RTCConfiguration) {
-    this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.PCManager);
     this.loggerOptions = loggerOptions;
+    this.log = getLogger(loggerOptions.loggerName ?? LoggerNames.PCManager, () => this.logContext);
+    this.iceLog = getLogger(LoggerNames.ICE, () => this.logContext);
 
     this.isPublisherConnectionRequired = mode !== 'subscriber-primary';
     this.isSubscriberConnectionRequired = mode === 'subscriber-primary';
@@ -151,7 +154,7 @@ export class PCTransportManager {
             publisher.removeTrack(sender);
           }
         } catch (e) {
-          this.log.warn('could not removeTrack', { ...this.logContext, error: e });
+          this.log.warn('could not removeTrack', { error: e });
         }
       }
     }
@@ -160,6 +163,7 @@ export class PCTransportManager {
   }
 
   async triggerIceRestart() {
+    this.iceLog.warn('triggering ICE restart');
     if (this.subscriber) {
       this.subscriber.restartingIce = true;
     }
@@ -170,6 +174,7 @@ export class PCTransportManager {
   }
 
   async addIceCandidate(candidate: RTCIceCandidateInit, target: SignalTarget) {
+    this.iceLog.debug('adding remote ICE candidate', { target, candidate });
     if (target === SignalTarget.PUBLISHER) {
       await this.publisher.addIceCandidate(candidate);
     } else {
@@ -179,7 +184,6 @@ export class PCTransportManager {
 
   async createSubscriberAnswerFromOffer(sd: RTCSessionDescriptionInit, offerId: number) {
     this.log.debug('received server offer', {
-      ...this.logContext,
       RTCSdpType: sd.type,
       sdp: sd.sdp,
       signalingState: this.subscriber?.getSignallingState().toString(),
@@ -200,6 +204,7 @@ export class PCTransportManager {
   }
 
   updateConfiguration(config: RTCConfiguration, iceRestart?: boolean) {
+    this.log.debug('updating rtc configuration', { iceRestart });
     this.publisher.setConfiguration(config);
     this.subscriber?.setConfiguration(config);
     if (iceRestart) {
@@ -215,7 +220,7 @@ export class PCTransportManager {
         this.publisher.getConnectionState() !== 'connected' &&
         this.publisher.getConnectionState() !== 'connecting'
       ) {
-        this.log.debug('negotiation required, start negotiating', this.logContext);
+        this.log.debug('negotiation required, start negotiating');
         this.publisher.negotiate();
       }
       await Promise.all(
@@ -368,7 +373,6 @@ export class PCTransportManager {
         `pc state change: from ${PCTransportState[previousState]} to ${
           PCTransportState[this.state]
         }`,
-        this.logContext,
       );
       this.onStateChange?.(
         this.state,
@@ -390,7 +394,7 @@ export class PCTransportManager {
 
     return new Promise<void>(async (resolve, reject) => {
       const abortHandler = () => {
-        this.log.warn('abort transport connection', this.logContext);
+        this.log.warn('abort transport connection');
         CriticalTimers.clearTimeout(connectTimeout);
 
         reject(ConnectionError.cancelled('room connection has been cancelled'));