@stream-io/video-client 1.35.1 → 1.36.1

package/src/events/mutes.ts

@@ -18,8 +18,7 @@ export const handleRemoteSoftMute = (call: Call) => {
       sessionId === localParticipant?.sessionId
     ) {
       const logger = call.logger;
-      logger(
-        'info',
+      logger.info(
         `Local participant's ${TrackType[type]} track is muted remotely`,
       );
       try {
@@ -33,14 +32,10 @@ export const handleRemoteSoftMute = (call: Call) => {
         ) {
           await call.screenShare.disable();
         } else {
-          logger(
-            'warn',
-            'Unsupported track type to soft mute',
-            TrackType[type],
-          );
+          logger.warn('Unsupported track type to soft mute', TrackType[type]);
         }
       } catch (error) {
-        logger('error', 'Failed to stop publishing', error);
+        logger.error('Failed to stop publishing', error);
       }
     }
   });

package/src/helpers/DynascaleManager.ts

@@ -15,7 +15,6 @@ import {
   takeWhile,
 } from 'rxjs';
 import { ViewportTracker } from './ViewportTracker';
-import { getLogger } from '../logger';
 import { isFirefox, isSafari } from './browsers';
 import {
   hasScreenShare,
@@ -27,6 +26,7 @@ import type { CallState } from '../store';
 import type { StreamSfuClient } from '../StreamSfuClient';
 import { SpeakerManager } from '../devices';
 import { getCurrentValue, setCurrentValue } from '../store/rxUtils';
+import { videoLoggerSystem } from '../logger';
 
 const DEFAULT_VIEWPORT_VISIBILITY_STATE: Record<
   VideoTrackType,
@@ -66,7 +66,7 @@ export class DynascaleManager {
    */
   readonly viewportTracker = new ViewportTracker();
 
-  private logger = getLogger(['DynascaleManager']);
+  private logger = videoLoggerSystem.getLogger('DynascaleManager');
   private callState: CallState;
   private speaker: SpeakerManager;
   private audioContext: AudioContext | undefined;
@@ -212,7 +212,7 @@ export class DynascaleManager {
       this.sfuClient
         ?.updateSubscriptions(this.trackSubscriptions)
         .catch((err: unknown) => {
-          this.logger('debug', `Failed to update track subscriptions`, err);
+          this.logger.debug(`Failed to update track subscriptions`, err);
         });
     };
 
@@ -324,7 +324,7 @@ export class DynascaleManager {
         // is not visible (e.g., has display: none).
         // we treat this as "unsubscription" as we don't want to keep
         // consuming bandwidth for a video that is not visible on the screen.
-        this.logger('debug', `Ignoring 0x0 dimension`, boundParticipant);
+        this.logger.debug(`Ignoring 0x0 dimension`, boundParticipant);
         dimension = undefined;
       }
       this.callState.updateParticipantTracks(trackType, {
@@ -468,7 +468,7 @@ export class DynascaleManager {
           setTimeout(() => {
             videoElement.srcObject = source ?? null;
             videoElement.play().catch((e) => {
-              this.logger('warn', `Failed to play stream`, e);
+              this.logger.warn(`Failed to play stream`, e);
             });
             // we add extra delay until we attempt to force-play
             // the participant's media stream in Firefox and Safari,
@@ -519,14 +519,14 @@ export class DynascaleManager {
       if (!deviceId) return;
       if ('setSinkId' in audioElement) {
         audioElement.setSinkId(deviceId).catch((e) => {
-          this.logger('warn', `Can't to set AudioElement sinkId`, e);
+          this.logger.warn(`Can't to set AudioElement sinkId`, e);
         });
       }
 
       if (audioContext && 'setSinkId' in audioContext) {
         // @ts-expect-error setSinkId is not available in all browsers
         audioContext.setSinkId(deviceId).catch((e) => {
-          this.logger('warn', `Can't to set AudioContext sinkId`, e);
+          this.logger.warn(`Can't to set AudioContext sinkId`, e);
         });
       }
     };
@@ -574,7 +574,7 @@ export class DynascaleManager {
             // we will play audio directly through the audio element in other browsers
             audioElement.muted = false;
             audioElement.play().catch((e) => {
-              this.logger('warn', `Failed to play audio stream`, e);
+              this.logger.warn(`Failed to play audio stream`, e);
             });
           }
 
@@ -630,7 +630,7 @@ export class DynascaleManager {
     if (this.audioContext?.state === 'suspended') {
       this.audioContext
         .resume()
-        .catch((err) => this.logger('warn', `Can't resume audio context`, err))
+        .catch((err) => this.logger.warn(`Can't resume audio context`, err))
         .then(() => {
           document.removeEventListener('click', this.resumeAudioContext);
         });

package/src/helpers/RNSpeechDetector.ts

@@ -1,7 +1,7 @@
 import { BaseStats } from '../stats';
 import { SoundStateChangeHandler } from './sound-detector';
 import { flatten } from '../stats/utils';
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 export class RNSpeechDetector {
   private pc1 = new RTCPeerConnection({});
@@ -64,8 +64,8 @@ export class RNSpeechDetector {
         this.stop();
       };
     } catch (error) {
-      const logger = getLogger(['RNSpeechDetector']);
-      logger('error', 'error handling permissions: ', error);
+      const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
+      logger.error('error handling permissions: ', error);
       return () => {};
     }
   }
@@ -164,8 +164,8 @@ export class RNSpeechDetector {
           }
         }
       } catch (error) {
-        const logger = getLogger(['RNSpeechDetector']);
-        logger('error', 'error checking audio level from stats', error);
+        const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
+        logger.error('error checking audio level from stats', error);
       }
     };
 

package/src/helpers/clientUtils.ts

@@ -4,7 +4,6 @@ import type {
   TokenOrProvider,
   User,
 } from '../coordinator/connection/types';
-import { getLogger } from '../logger';
 import { StreamClient } from '../coordinator/connection/client';
 import { getSdkInfo } from './client-details';
 import { SdkType } from '../gen/video/sfu/models/models';
@@ -50,12 +49,11 @@ export const createCoordinatorClient = (
   options: StreamClientOptions | undefined,
 ) => {
   const clientAppIdentifier = getClientAppIdentifier(options);
-  const coordinatorLogger = getLogger(['coordinator']);
+
   return new StreamClient(apiKey, {
     persistUserOnConnectionFailure: true,
     ...options,
     clientAppIdentifier,
-    logger: coordinatorLogger,
   });
 };
 

package/src/helpers/ensureExhausted.ts

@@ -1,5 +1,5 @@
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 export const ensureExhausted = (x: never, message: string) => {
-  getLogger(['helpers'])('warn', message, x);
+  videoLoggerSystem.getLogger('helpers').warn(message, x);
 };

package/src/logger.ts

@@ -1,17 +1,6 @@
-import { Logger, LogLevel } from './coordinator/connection/types';
+import * as scopedLogger from '@stream-io/logger';
 import { isReactNative } from './helpers/platforms';
-
-// log levels, sorted by verbosity
-export const logLevels: Record<LogLevel, number> = Object.freeze({
-  trace: 0,
-  debug: 1,
-  info: 2,
-  warn: 3,
-  error: 4,
-});
-
-let logger: Logger | undefined;
-let level: LogLevel = 'info';
+import type { Logger } from './coordinator/connection/types';
 
 export const logToConsole: Logger = (logLevel, message, ...args) => {
   let logMethod;
@@ -46,26 +35,12 @@ export const logToConsole: Logger = (logLevel, message, ...args) => {
   logMethod(message, ...args);
 };
 
-export const setLogger = (l: Logger, lvl?: LogLevel) => {
-  logger = l;
-  if (lvl) {
-    setLogLevel(lvl);
-  }
-};
+/**
+ * @internal
+ */
+export type ScopedLogger = scopedLogger.Logger;
 
-export const setLogLevel = (l: LogLevel) => {
-  level = l;
-};
-
-export const getLogLevel = (): LogLevel => level;
+export { LogLevelEnum } from '@stream-io/logger';
+export type { LogLevel, Sink } from '@stream-io/logger';
 
-export const getLogger = (withTags?: string[]) => {
-  const loggerMethod = logger || logToConsole;
-  const tags = (withTags || []).filter(Boolean).join(':');
-  const result: Logger = (logLevel, message, ...args) => {
-    if (logLevels[logLevel] >= logLevels[level]) {
-      loggerMethod(logLevel, `[${tags}]: ${message}`, ...args);
-    }
-  };
-  return result;
-};
+export const videoLoggerSystem = scopedLogger.createLoggerSystem();

package/src/rpc/__tests__/createClient.test.ts

@@ -8,6 +8,7 @@ import {
 import { TwirpFetchTransport } from '@protobuf-ts/twirp-transport';
 import { NextUnaryFn, UnaryCall } from '@protobuf-ts/runtime-rpc';
 import { promiseWithResolvers } from '../../helpers/promise';
+import { ScopedLogger } from '../../logger';
 
 describe('createClient', () => {
   it('should create a client with TwirpFetchTransport', () => {
@@ -30,7 +31,10 @@ describe('createClient', () => {
 
   it('withRequestLogger should log the request', () => {
     const logger = vi.fn();
-    const interceptor = withRequestLogger(logger, 'debug');
+    const interceptor = withRequestLogger(
+      { debug: logger } as unknown as ScopedLogger,
+      'debug',
+    );
     const next = vi.fn().mockReturnValue({});
     // @ts-expect-error - private field
     interceptor.interceptUnary(next, { name: 'test' }, null, null);

package/src/rpc/createClient.ts

@@ -10,9 +10,10 @@ import {
   TwirpOptions,
 } from '@protobuf-ts/twirp-transport';
 import { SignalServerClient } from '../gen/video/sfu/signal_rpc/signal.client';
-import { Logger, LogLevel } from '../coordinator/connection/types';
 import type { Trace } from '../stats';
 import type { SfuResponseWithError } from './retryable';
+import type { ScopedLogger } from '../logger';
+import type { LogLevel } from '@stream-io/logger';
 
 const defaultOptions: TwirpOptions = {
   baseUrl: '',
@@ -40,7 +41,7 @@ export const withHeaders = (
 };
 
 export const withRequestLogger = (
-  logger: Logger,
+  logger: ScopedLogger,
   level: LogLevel,
 ): RpcInterceptor => {
   return {
@@ -51,7 +52,7 @@ export const withRequestLogger = (
       options: RpcOptions,
     ): UnaryCall => {
       const invocation = next(method, input, options);
-      logger(level, `Invoked SFU RPC method ${method.name}`, {
+      logger[level](`Invoked SFU RPC method ${method.name}`, {
         request: invocation.request,
         headers: invocation.requestHeaders,
         response: invocation.response,

package/src/rpc/retryable.ts

@@ -6,7 +6,7 @@ import {
 import { TwirpErrorCode } from '@protobuf-ts/twirp-transport';
 import { retryInterval, sleep } from '../coordinator/connection/utils';
 import { Error as SfuError } from '../gen/video/sfu/models/models';
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 /**
  * An internal interface which asserts that "retryable" SFU responses
@@ -48,7 +48,9 @@ export const retryable = async <
         err.code === TwirpErrorCode[TwirpErrorCode.cancelled];
       const isAborted = signal?.aborted ?? false;
       if (isRequestCancelled || isAborted) throw err;
-      getLogger(['sfu-client', 'rpc'])('debug', `rpc failed (${attempt})`, err);
+      videoLoggerSystem
+        .getLogger('sfu-client', { tags: ['rpc'] })
+        .debug(`rpc failed (${attempt})`, err);
       attempt++;
     }
   } while (!result || result.response.error?.shouldRetry);

package/src/rtc/BasePeerConnection.ts

@@ -1,8 +1,5 @@
-import { getLogger } from '../logger';
-import type {
-  CallEventListener,
-  Logger,
-} from '../coordinator/connection/types';
+import { ScopedLogger, videoLoggerSystem } from '../logger';
+import type { CallEventListener } from '../coordinator/connection/types';
 import { CallingState, CallState } from '../store';
 import { createSafeAsyncSubscription } from '../store/rxUtils';
 import {
@@ -16,18 +13,20 @@ import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
 import { withoutConcurrency } from '../helpers/concurrency';
 import { StatsTracer, Tracer, traceRTCPeerConnection } from '../stats';
-import { BasePeerConnectionOpts, OnReconnectionNeeded } from './types';
+import type { BasePeerConnectionOpts, OnReconnectionNeeded } from './types';
+import type { ClientPublishOptions } from '../types';
 
 /**
  * A base class for the `Publisher` and `Subscriber` classes.
  * @internal
  */
 export abstract class BasePeerConnection {
-  protected readonly logger: Logger;
+  protected readonly logger: ScopedLogger;
   protected readonly peerType: PeerType;
   protected readonly pc: RTCPeerConnection;
   protected readonly state: CallState;
   protected readonly dispatcher: Dispatcher;
+  protected readonly clientPublishOptions?: ClientPublishOptions;
   protected sfuClient: StreamSfuClient;
 
   private onReconnectionNeeded?: OnReconnectionNeeded;
@@ -58,6 +57,7 @@ export abstract class BasePeerConnection {
       onReconnectionNeeded,
       tag,
       enableTracing,
+      clientPublishOptions,
       iceRestartDelay = 2500,
     }: BasePeerConnectionOpts,
   ) {
@@ -66,11 +66,12 @@ export abstract class BasePeerConnection {
     this.state = state;
     this.dispatcher = dispatcher;
     this.iceRestartDelay = iceRestartDelay;
+    this.clientPublishOptions = clientPublishOptions;
     this.onReconnectionNeeded = onReconnectionNeeded;
-    this.logger = getLogger([
+    this.logger = videoLoggerSystem.getLogger(
       peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher',
-      tag,
-    ]);
+      { tags: [tag] },
+    );
     this.pc = this.createPeerConnection(connectionConfig);
     this.stats = new StatsTracer(this.pc, peerType, this.trackIdToTrackType);
     if (enableTracing) {
@@ -142,13 +143,13 @@ export abstract class BasePeerConnection {
   protected tryRestartIce = () => {
     this.restartIce().catch((e) => {
       const reason = 'restartICE() failed, initiating reconnect';
-      this.logger('error', reason, e);
+      this.logger.error(reason, e);
       const strategy =
         e instanceof NegotiationError &&
         e.error.code === ErrorCode.PARTICIPANT_SIGNAL_LOST
           ? WebsocketReconnectStrategy.FAST
           : WebsocketReconnectStrategy.REJOIN;
-      this.onReconnectionNeeded?.(strategy, reason);
+      this.onReconnectionNeeded?.(strategy, reason, this.peerType);
     });
   };
 
@@ -165,7 +166,7 @@ export abstract class BasePeerConnection {
         const lockKey = `pc.${this.lock}.${event}`;
         withoutConcurrency(lockKey, async () => fn(e)).catch((err) => {
           if (this.isDisposed) return;
-          this.logger('warn', `Error handling ${event}`, err);
+          this.logger.warn(`Error handling ${event}`, err);
         });
       }),
     );
@@ -187,7 +188,7 @@ export abstract class BasePeerConnection {
       async (candidate) => {
         return this.pc.addIceCandidate(candidate).catch((e) => {
           if (this.isDisposed) return;
-          this.logger('warn', `ICE candidate error`, e, candidate);
+          this.logger.warn(`ICE candidate error`, e, candidate);
         });
       },
     );
@@ -240,7 +241,7 @@ export abstract class BasePeerConnection {
   private onIceCandidate = (e: RTCPeerConnectionIceEvent) => {
     const { candidate } = e;
     if (!candidate) {
-      this.logger('debug', 'null ice candidate');
+      this.logger.debug('null ice candidate');
       return;
     }
 
@@ -249,7 +250,7 @@ export abstract class BasePeerConnection {
       .iceTrickle({ peerType: this.peerType, iceCandidate })
       .catch((err) => {
         if (this.isDisposed) return;
-        this.logger('warn', `ICETrickle failed`, err);
+        this.logger.warn(`ICETrickle failed`, err);
       });
   };
 
@@ -272,7 +273,7 @@ export abstract class BasePeerConnection {
    */
   private onConnectionStateChange = async () => {
     const state = this.pc.connectionState;
-    this.logger('debug', `Connection state changed`, state);
+    this.logger.debug(`Connection state changed`, state);
     if (this.tracer && (state === 'connected' || state === 'failed')) {
       try {
         const stats = await this.stats.get();
@@ -287,6 +288,7 @@ export abstract class BasePeerConnection {
       this.onReconnectionNeeded?.(
         WebsocketReconnectStrategy.REJOIN,
         'Connection failed',
+        this.peerType,
       );
       return;
     }
@@ -299,7 +301,7 @@ export abstract class BasePeerConnection {
    */
   private onIceConnectionStateChange = () => {
     const state = this.pc.iceConnectionState;
-    this.logger('debug', `ICE connection state changed`, state);
+    this.logger.debug(`ICE connection state changed`, state);
     this.handleConnectionStateUpdate(state);
   };
 
@@ -316,14 +318,14 @@ export abstract class BasePeerConnection {
     switch (state) {
       case 'failed':
         // in the `failed` state, we try to restart ICE immediately
-        this.logger('info', 'restartICE due to failed connection');
+        this.logger.info('restartICE due to failed connection');
         this.tryRestartIce();
         break;
 
       case 'disconnected':
         // in the `disconnected` state, we schedule a restartICE() after a delay
         // as the browser might recover the connection in the meantime
-        this.logger('info', 'disconnected connection, scheduling restartICE');
+        this.logger.info('disconnected connection, scheduling restartICE');
         clearTimeout(this.iceRestartTimeout);
         this.iceRestartTimeout = setTimeout(() => {
           const currentState = this.pc.iceConnectionState;
@@ -336,7 +338,7 @@ export abstract class BasePeerConnection {
       case 'connected':
         // in the `connected` state, we clear the ice restart timeout if it exists
         if (this.iceRestartTimeout) {
-          this.logger('info', 'connected connection, canceling restartICE');
+          this.logger.info('connected connection, canceling restartICE');
           clearTimeout(this.iceRestartTimeout);
           this.iceRestartTimeout = undefined;
         }
@@ -352,20 +354,20 @@ export abstract class BasePeerConnection {
       e instanceof RTCPeerConnectionIceErrorEvent
         ? `${e.errorCode}: ${e.errorText}`
         : e;
-    this.logger('debug', 'ICE Candidate error', errorMessage);
+    this.logger.debug('ICE Candidate error', errorMessage);
   };
 
   /**
    * Handles the ICE gathering state change event.
    */
   private onIceGatherChange = () => {
-    this.logger('debug', `ICE Gathering State`, this.pc.iceGatheringState);
+    this.logger.debug(`ICE Gathering State`, this.pc.iceGatheringState);
   };
 
   /**
    * Handles the signaling state change event.
    */
   private onSignalingChange = () => {
-    this.logger('debug', `Signaling state changed`, this.pc.signalingState);
+    this.logger.debug(`Signaling state changed`, this.pc.signalingState);
   };
 }

package/src/rtc/Dispatcher.ts

@@ -1,6 +1,6 @@
 import { CallEventListener, EventTypes } from '../coordinator/connection/types';
 import type { SfuEvent } from '../gen/video/sfu/event/events';
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 export type SfuEventKinds = NonNullable<SfuEvent['eventPayload']['oneofKind']>;
 export type AllSfuEvents = {
@@ -53,7 +53,7 @@ export const isSfuEvent = (
 };
 
 export class Dispatcher {
-  private readonly logger = getLogger(['Dispatcher']);
+  private readonly logger = videoLoggerSystem.getLogger('Dispatcher');
   private subscribers: Partial<
     Record<SfuEventKinds, CallEventListener<any>[] | undefined>
   > = {};
@@ -65,14 +65,14 @@ export class Dispatcher {
     const eventKind = message.eventPayload.oneofKind;
     if (!eventKind) return;
     const payload = message.eventPayload[eventKind];
-    this.logger('debug', `Dispatching ${eventKind}, tag=${tag}`, payload);
+    this.logger.debug(`Dispatching ${eventKind}, tag=${tag}`, payload);
     const listeners = this.subscribers[eventKind];
     if (!listeners) return;
     for (const fn of listeners) {
       try {
         fn(payload);
       } catch (e) {
-        this.logger('warn', 'Listener failed with error', e);
+        this.logger.warn('Listener failed with error', e);
       }
     }
   };

package/src/rtc/IceTrickleBuffer.ts

@@ -1,7 +1,7 @@
 import { ReplaySubject } from 'rxjs';
 import { ICETrickle } from '../gen/video/sfu/event/events';
 import { PeerType } from '../gen/video/sfu/models/models';
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 /**
  * A buffer for ICE Candidates. Used for ICE Trickle:
@@ -20,8 +20,8 @@ export class IceTrickleBuffer {
     } else if (iceTrickle.peerType === PeerType.PUBLISHER_UNSPECIFIED) {
       this.publisherCandidates.next(iceCandidate);
     } else {
-      const logger = getLogger(['sfu-client']);
-      logger('warn', `ICETrickle, Unknown peer type`, iceTrickle);
+      const logger = videoLoggerSystem.getLogger('sfu-client');
+      logger.warn(`ICETrickle, Unknown peer type`, iceTrickle);
     }
   };
 
@@ -37,8 +37,8 @@ const toIceCandidate = (
   try {
     return JSON.parse(iceTrickle.iceCandidate);
   } catch (e) {
-    const logger = getLogger(['sfu-client']);
-    logger('error', `Failed to parse ICE Trickle`, e, iceTrickle);
+    const logger = videoLoggerSystem.getLogger('sfu-client');
+    logger.error(`Failed to parse ICE Trickle`, e, iceTrickle);
     return undefined;
   }
 };

package/src/rtc/Publisher.ts

@@ -1,7 +1,7 @@
 import { BasePeerConnection } from './BasePeerConnection';
-import {
+import type {
+  BasePeerConnectionOpts,
   PublishBundle,
-  PublisherConstructorOpts,
   TrackPublishOptions,
 } from './types';
 import { NegotiationError } from './NegotiationError';
@@ -21,7 +21,7 @@ import {
 } from './layers';
 import { isSvcCodec } from './codecs';
 import { isAudioTrackType } from './helpers/tracks';
-import { extractMid } from './helpers/sdp';
+import { extractMid, removeCodecsExcept } from './helpers/sdp';
 import { withoutConcurrency } from '../helpers/concurrency';
 import { isReactNative } from '../helpers/platforms';
 
@@ -38,7 +38,10 @@ export class Publisher extends BasePeerConnection {
   /**
    * Constructs a new `Publisher` instance.
    */
-  constructor({ publishOptions, ...baseOptions }: PublisherConstructorOpts) {
+  constructor(
+    baseOptions: BasePeerConnectionOpts,
+    publishOptions: PublishOption[],
+  ) {
     super(PeerType.PUBLISHER_UNSPECIFIED, baseOptions);
     this.publishOptions = publishOptions;
 
@@ -136,7 +139,7 @@ export class Publisher extends BasePeerConnection {
     await transceiver.sender.setParameters(params);
 
     const trackType = publishOption.trackType;
-    this.logger('debug', `Added ${TrackType[trackType]} transceiver`);
+    this.logger.debug(`Added ${TrackType[trackType]} transceiver`);
     this.transceiverCache.add({ publishOption, transceiver, options });
     this.trackIdToTrackType.set(track.id, trackType);
 
@@ -273,7 +276,7 @@ export class Publisher extends BasePeerConnection {
     const enabledLayers = layers.filter((l) => l.active);
 
     const tag = 'Update publish quality:';
-    this.logger('info', `${tag} requested layers by SFU:`, enabledLayers);
+    this.logger.info(`${tag} requested layers by SFU:`, enabledLayers);
 
     const transceiverId = this.transceiverCache.find(
       (t) =>
@@ -282,12 +285,12 @@ export class Publisher extends BasePeerConnection {
     );
     const sender = transceiverId?.transceiver.sender;
     if (!sender) {
-      return this.logger('warn', `${tag} no video sender found.`);
+      return this.logger.warn(`${tag} no video sender found.`);
     }
 
     const params = sender.getParameters();
     if (params.encodings.length === 0) {
-      return this.logger('warn', `${tag} there are no encodings set.`);
+      return this.logger.warn(`${tag} there are no encodings set.`);
     }
 
     const codecInUse = transceiverId?.publishOption.codec?.name;
@@ -343,21 +346,21 @@ export class Publisher extends BasePeerConnection {
 
     const activeEncoders = params.encodings.filter((e) => e.active);
     if (!changed) {
-      return this.logger('info', `${tag} no change:`, activeEncoders);
+      return this.logger.info(`${tag} no change:`, activeEncoders);
     }
 
     await sender.setParameters(params);
-    this.logger('info', `${tag} enabled rids:`, activeEncoders);
+    this.logger.info(`${tag} enabled rids:`, activeEncoders);
   };
 
   /**
    * Restarts the ICE connection and renegotiates with the SFU.
    */
   restartIce = async (): Promise<void> => {
-    this.logger('debug', 'Restarting ICE connection');
+    this.logger.debug('Restarting ICE connection');
     const signalingState = this.pc.signalingState;
     if (this.isIceRestarting || signalingState === 'have-local-offer') {
-      this.logger('debug', 'ICE restart is already in progress');
+      this.logger.debug('ICE restart is already in progress');
       return;
     }
     await this.negotiate({ iceRestart: true });
@@ -378,7 +381,12 @@ export class Publisher extends BasePeerConnection {
         this.isIceRestarting = options?.iceRestart ?? false;
         await this.pc.setLocalDescription(offer);
 
-        const { sdp = '' } = offer;
+        const { sdp: baseSdp = '' } = offer;
+        const { dangerouslyForceCodec, fmtpLine } =
+          this.clientPublishOptions || {};
+        const sdp = dangerouslyForceCodec
+          ? removeCodecsExcept(baseSdp, dangerouslyForceCodec, fmtpLine)
+          : baseSdp;
         const { response } = await this.sfuClient.setPublisher({ sdp, tracks });
         if (response.error) throw new NegotiationError(response.error);