@stream-io/video-client 1.35.1 → 1.36.1

package/src/Call.ts

@@ -1,5 +1,6 @@
 import { StreamSfuClient } from './StreamSfuClient';
 import {
+  BasePeerConnectionOpts,
   Dispatcher,
   getGenericSdp,
   isAudioTrackType,
@@ -25,6 +26,7 @@ import {
   createSubscription,
   getCurrentValue,
 } from './store/rxUtils';
+import { ScopedLogger, videoLoggerSystem } from './logger';
 import type {
   AcceptCallResponse,
   BlockUserRequest,
@@ -117,6 +119,7 @@ import {
   ClientDetails,
   Codec,
   ParticipantSource,
+  PeerType,
   PublishOption,
   SubscribeOption,
   TrackType,
@@ -139,12 +142,10 @@ import {
   AllCallEvents,
   CallEventListener,
   ErrorFromResponse,
-  Logger,
   RejectReason,
   StreamCallEvent,
 } from './coordinator/connection/types';
 import { getClientDetails } from './helpers/client-details';
-import { getLogger } from './logger';
 import {
   CameraManager,
   MicrophoneManager,
@@ -229,7 +230,7 @@ export class Call {
    */
   readonly permissionsContext = new PermissionsContext();
   readonly tracer = new Tracer(null);
-  readonly logger: Logger;
+  readonly logger: ScopedLogger;
 
   /**
    * The event dispatcher instance dedicated to this Call instance.
@@ -312,7 +313,7 @@ export class Call {
     this.streamClient = streamClient;
     this.clientStore = clientStore;
     this.streamClientBasePath = `/call/${this.type}/${this.id}`;
-    this.logger = getLogger(['Call']);
+    this.logger = videoLoggerSystem.getLogger('Call');
 
     const callTypeConfig = CallTypes.get(type);
     const participantSorter =
@@ -396,9 +397,9 @@ export class Call {
         if (!blockedUserIds || blockedUserIds.length === 0) return;
         const currentUserId = this.currentUserId;
         if (currentUserId && blockedUserIds.includes(currentUserId)) {
-          this.logger('info', 'Leaving call because of being blocked');
+          this.logger.info('Leaving call because of being blocked');
           await this.leave({ message: 'user blocked' }).catch((err) => {
-            this.logger('error', 'Error leaving call after being blocked', err);
+            this.logger.error('Error leaving call after being blocked', err);
           });
         }
       }),
@@ -442,8 +443,7 @@ export class Call {
           !hasPending(this.joinLeaveConcurrencyTag)
         ) {
           this.leave().catch(() => {
-            this.logger(
-              'error',
+            this.logger.error(
               'Could not leave a call that was accepted or rejected elsewhere',
             );
           });
@@ -526,8 +526,7 @@ export class Call {
             break;
         }
       } catch (err) {
-        this.logger(
-          'error',
+        this.logger.error(
           `Can't disable mic/camera/screenshare after revoked permissions`,
           err,
         );
@@ -886,12 +885,12 @@ export class Call {
     maxJoinRetries = Math.max(maxJoinRetries, 1);
     for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
       try {
-        this.logger('trace', `Joining call (${attempt})`, this.cid);
+        this.logger.trace(`Joining call (${attempt})`, this.cid);
         await this.doJoin(data);
         delete joinData.migrating_from;
         break;
       } catch (err) {
-        this.logger('warn', `Failed to join call (${attempt})`, this.cid);
+        this.logger.warn(`Failed to join call (${attempt})`, this.cid);
         if (err instanceof ErrorFromResponse && err.unrecoverable) {
           // if the error is unrecoverable, we should not retry as that signals
           // that connectivity is good, but the coordinator doesn't allow the user
@@ -927,7 +926,7 @@ export class Call {
 
     this.joinCallData = data;
 
-    this.logger('debug', 'Starting join flow');
+    this.logger.debug('Starting join flow');
     this.state.setCallingState(CallingState.JOINING);
 
     const performingMigration =
@@ -990,9 +989,11 @@ export class Call {
       // prepare a generic SDP and send it to the SFU.
       // these are throw-away SDPs that the SFU will use to determine
       // the capabilities of the client (codec support, etc.)
+      const { dangerouslyForceCodec, fmtpLine, subscriberFmtpLine } =
+        this.clientPublishOptions || {};
       const [subscriberSdp, publisherSdp] = await Promise.all([
-        getGenericSdp('recvonly'),
-        getGenericSdp('sendonly'),
+        getGenericSdp('recvonly', dangerouslyForceCodec, subscriberFmtpLine),
+        getGenericSdp('sendonly', dangerouslyForceCodec, fmtpLine),
       ]);
       const isReconnecting =
         this.reconnectStrategy !== WebsocketReconnectStrategy.UNSPECIFIED;
@@ -1031,7 +1032,7 @@ export class Call {
           );
         }
       } catch (error) {
-        this.logger('warn', 'Join SFU request failed', error);
+        this.logger.warn('Join SFU request failed', error);
         sfuClient.close(
           StreamSfuClient.JOIN_FAILED,
           'Join request failed, connection considered unhealthy',
@@ -1103,7 +1104,7 @@ export class Call {
     this.reconnectStrategy = WebsocketReconnectStrategy.UNSPECIFIED;
     this.reconnectReason = '';
 
-    this.logger('info', `Joined call ${this.cid}`);
+    this.logger.info(`Joined call ${this.cid}`);
   };
 
   /**
@@ -1240,20 +1241,23 @@ export class Call {
     if (closePreviousInstances && this.subscriber) {
       this.subscriber.dispose();
     }
-    this.subscriber = new Subscriber({
+    const basePeerConnectionOptions: BasePeerConnectionOpts = {
       sfuClient,
       dispatcher: this.dispatcher,
       state: this.state,
       connectionConfig,
       tag: sfuClient.tag,
       enableTracing,
-      onReconnectionNeeded: (kind, reason) => {
+      clientPublishOptions: this.clientPublishOptions,
+      onReconnectionNeeded: (kind, reason, peerType) => {
         this.reconnect(kind, reason).catch((err) => {
-          const message = `[Reconnect] Error reconnecting after a subscriber error: ${reason}`;
-          this.logger('warn', message, err);
+          const message = `[Reconnect] Error reconnecting, after a ${PeerType[peerType]} error: ${reason}`;
+          this.logger.warn(message, err);
         });
       },
-    });
+    };
+
+    this.subscriber = new Subscriber(basePeerConnectionOptions);
 
     // anonymous users can't publish anything hence, there is no need
     // to create Publisher Peer Connection for them
@@ -1262,21 +1266,7 @@ export class Call {
       if (closePreviousInstances && this.publisher) {
         this.publisher.dispose();
       }
-      this.publisher = new Publisher({
-        sfuClient,
-        dispatcher: this.dispatcher,
-        state: this.state,
-        connectionConfig,
-        publishOptions,
-        tag: sfuClient.tag,
-        enableTracing,
-        onReconnectionNeeded: (kind, reason) => {
-          this.reconnect(kind, reason).catch((err) => {
-            const message = `[Reconnect] Error reconnecting after a publisher error: ${reason}`;
-            this.logger('warn', message, err);
-          });
-        },
-      });
+      this.publisher = new Publisher(basePeerConnectionOptions, publishOptions);
     }
 
     this.statsReporter?.stop();
@@ -1358,7 +1348,7 @@ export class Call {
     sfuClient: StreamSfuClient,
     reason: string,
   ) => {
-    this.logger('debug', '[Reconnect] SFU signal connection closed');
+    this.logger.debug('[Reconnect] SFU signal connection closed');
     const { callingState } = this.state;
     if (
       // SFU WS closed before we finished current join,
@@ -1381,7 +1371,7 @@ export class Call {
         ? WebsocketReconnectStrategy.FAST
         : WebsocketReconnectStrategy.REJOIN;
     this.reconnect(strategy, reason).catch((err) => {
-      this.logger('warn', '[Reconnect] Error reconnecting', err);
+      this.logger.warn('[Reconnect] Error reconnecting', err);
     });
   };
 
@@ -1427,8 +1417,7 @@ export class Call {
           reconnectingTime / 1000 > this.disconnectionTimeoutSeconds;
 
         if (shouldGiveUpReconnecting) {
-          this.logger(
-            'warn',
+          this.logger.warn(
             '[Reconnect] Stopping reconnection attempts after reaching disconnection timeout',
           );
           await markAsReconnectingFailed();
@@ -1445,16 +1434,14 @@ export class Call {
           // wait until the network is available
           await this.networkAvailableTask?.promise;
 
-          this.logger(
-            'info',
+          this.logger.info(
             `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[this.reconnectStrategy]}`,
           );
 
           switch (this.reconnectStrategy) {
             case WebsocketReconnectStrategy.UNSPECIFIED:
             case WebsocketReconnectStrategy.DISCONNECT:
-              this.logger(
-                'debug',
+              this.logger.debug(
                 `[Reconnect] No-op strategy ${currentStrategy}`,
               );
               break;
@@ -1477,8 +1464,7 @@ export class Call {
           break; // do-while loop, reconnection worked, exit the loop
         } catch (error) {
           if (this.state.callingState === CallingState.OFFLINE) {
-            this.logger(
-              'debug',
+            this.logger.debug(
               `[Reconnect] Can't reconnect while offline, stopping reconnection attempts`,
             );
             break;
@@ -1486,8 +1472,7 @@ export class Call {
             // network change event will trigger the reconnection
           }
           if (error instanceof ErrorFromResponse && error.unrecoverable) {
-            this.logger(
-              'warn',
+            this.logger.warn(
               `[Reconnect] Can't reconnect due to coordinator unrecoverable error`,
               error,
             );
@@ -1520,8 +1505,7 @@ export class Call {
             : WebsocketReconnectStrategy.FAST;
           this.reconnectStrategy = nextStrategy;
 
-          this.logger(
-            'info',
+          this.logger.info(
             `[Reconnect] ${currentStrategy} (${this.reconnectAttempts}) failed. Attempting with ${WebsocketReconnectStrategy[nextStrategy]}`,
             error,
           );
@@ -1531,7 +1515,7 @@ export class Call {
         this.state.callingState !== CallingState.RECONNECTING_FAILED &&
         this.state.callingState !== CallingState.LEFT
       );
-      this.logger('info', '[Reconnect] Reconnection flow finished');
+      this.logger.info('[Reconnect] Reconnection flow finished');
     });
   };
 
@@ -1633,7 +1617,7 @@ export class Call {
     // handles the legacy "goAway" event
     const unregisterGoAway = this.on('goAway', () => {
       this.reconnect(WebsocketReconnectStrategy.MIGRATE, 'goAway').catch(
-        (err) => this.logger('warn', '[Reconnect] Error reconnecting', err),
+        (err) => this.logger.warn('[Reconnect] Error reconnecting', err),
       );
     });
 
@@ -1643,11 +1627,11 @@ export class Call {
       if (strategy === WebsocketReconnectStrategy.UNSPECIFIED) return;
       if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
         this.leave({ message: 'SFU instructed to disconnect' }).catch((err) => {
-          this.logger('warn', `Can't leave call after disconnect request`, err);
+          this.logger.warn(`Can't leave call after disconnect request`, err);
         });
       } else {
         this.reconnect(strategy, error?.message || 'SFU Error').catch((err) => {
-          this.logger('warn', '[Reconnect] Error reconnecting', err);
+          this.logger.warn('[Reconnect] Error reconnecting', err);
         });
       }
     });
@@ -1657,7 +1641,7 @@ export class Call {
       (e) => {
         this.tracer.trace('network.changed', e);
         if (!e.online) {
-          this.logger('debug', '[Reconnect] Going offline');
+          this.logger.debug('[Reconnect] Going offline');
           if (!this.hasJoinedOnce) return;
           this.lastOfflineTimestamp = Date.now();
           // create a new task that would resolve when the network is available
@@ -1674,8 +1658,7 @@ export class Call {
             }
 
             this.reconnect(strategy, 'Going online').catch((err) => {
-              this.logger(
-                'warn',
+              this.logger.warn(
                 '[Reconnect] Error reconnecting after going online',
                 err,
               );
@@ -1685,7 +1668,7 @@ export class Call {
           this.sfuStatsReporter?.stop();
           this.state.setCallingState(CallingState.OFFLINE);
         } else {
-          this.logger('debug', '[Reconnect] Going online');
+          this.logger.debug('[Reconnect] Going online');
           this.sfuClient?.close(
             StreamSfuClient.DISPOSE_OLD_SOCKET,
             'Closing WS to reconnect after going online',
@@ -1875,14 +1858,12 @@ export class Call {
    * @param options the options to use.
    */
   updatePublishOptions = (options: ClientPublishOptions) => {
-    this.logger(
-      'warn',
+    this.logger.warn(
       '[call.updatePublishOptions]: You are manually overriding the publish options for this call. ' +
         'This is not recommended, and it can cause call stability/compatibility issues. Use with caution.',
     );
     if (this.state.callingState === CallingState.JOINED) {
-      this.logger(
-        'warn',
+      this.logger.warn(
         'Updating publish options after joining the call does not have an effect',
       );
     }
@@ -1896,7 +1877,7 @@ export class Call {
    */
   notifyNoiseCancellationStarting = async () => {
     return this.sfuClient?.startNoiseCancellation().catch((err) => {
-      this.logger('warn', 'Failed to notify start of noise cancellation', err);
+      this.logger.warn('Failed to notify start of noise cancellation', err);
     });
   };
 
@@ -1907,7 +1888,7 @@ export class Call {
    */
   notifyNoiseCancellationStopped = async () => {
     return this.sfuClient?.stopNoiseCancellation().catch((err) => {
-      this.logger('warn', 'Failed to notify stop of noise cancellation', err);
+      this.logger.warn('Failed to notify stop of noise cancellation', err);
     });
   };
 
@@ -2489,7 +2470,7 @@ export class Call {
         reason: 'timeout',
         message: `ringing timeout - ${this.isCreatedByMe ? 'no one accepted' : `user didn't interact with incoming call screen`}`,
       }).catch((err) => {
-        this.logger('error', 'Failed to drop call', err);
+        this.logger.error('Failed to drop call', err);
       });
     }, timeoutInMs);
   };
@@ -2653,10 +2634,10 @@ export class Call {
     publish: boolean,
   ) => {
     await this.camera.apply(settings.video, publish).catch((err) => {
-      this.logger('warn', 'Camera init failed', err);
+      this.logger.warn('Camera init failed', err);
     });
     await this.microphone.apply(settings.audio, publish).catch((err) => {
-      this.logger('warn', 'Mic init failed', err);
+      this.logger.warn('Mic init failed', err);
     });
   };
 

package/src/StreamSfuClient.ts

@@ -29,8 +29,7 @@ import { ICETrickle } from './gen/video/sfu/models/models';
 import { StreamClient } from './coordinator/connection/client';
 import { generateUUIDv4 } from './coordinator/connection/utils';
 import { Credentials } from './gen/coordinator';
-import { Logger } from './coordinator/connection/types';
-import { getLogger, getLogLevel } from './logger';
+import { ScopedLogger, videoLoggerSystem } from './logger';
 import {
   makeSafePromise,
   PromiseWithResolvers,
@@ -152,7 +151,7 @@ export class StreamSfuClient {
   private readonly unsubscribeIceTrickle: () => void;
   private readonly unsubscribeNetworkChanged: () => void;
   private readonly onSignalClose: ((reason: string) => void) | undefined;
-  private readonly logger: Logger;
+  private readonly logger: ScopedLogger;
   readonly tag: string;
   private readonly credentials: Credentials;
   private readonly dispatcher: Dispatcher;
@@ -219,7 +218,7 @@ export class StreamSfuClient {
     this.edgeName = server.edge_name;
     this.joinResponseTimeout = joinResponseTimeout;
     this.tag = tag;
-    this.logger = getLogger(['SfuClient', tag]);
+    this.logger = videoLoggerSystem.getLogger('SfuClient', { tags: [tag] });
     this.tracer = enableTracing
       ? new Tracer(`${tag}-${this.edgeName}`)
       : undefined;
@@ -228,7 +227,8 @@ export class StreamSfuClient {
       interceptors: [
         withHeaders({ Authorization: `Bearer ${token}` }),
         this.tracer && withRequestTracer(this.tracer.trace),
-        getLogLevel() === 'trace' && withRequestLogger(this.logger, 'trace'),
+        this.logger.getLogLevel() === 'trace' &&
+          withRequestLogger(this.logger, 'trace'),
       ].filter((v) => !!v),
     });
 
@@ -346,7 +346,7 @@ export class StreamSfuClient {
   close = (code: number = StreamSfuClient.NORMAL_CLOSURE, reason?: string) => {
     this.isClosingClean = code !== StreamSfuClient.ERROR_CONNECTION_UNHEALTHY;
     if (this.signalWs.readyState === WebSocket.OPEN) {
-      this.logger('debug', `Closing SFU WS connection: ${code} - ${reason}`);
+      this.logger.debug(`Closing SFU WS connection: ${code} - ${reason}`);
       this.signalWs.close(code, `js-client: ${reason}`);
       this.signalWs.removeEventListener('close', this.handleWebSocketClose);
     }
@@ -354,7 +354,7 @@ export class StreamSfuClient {
   };
 
   private dispose = () => {
-    this.logger('debug', 'Disposing SFU client');
+    this.logger.debug('Disposing SFU client');
     this.unsubscribeIceTrickle();
     this.unsubscribeNetworkChanged();
     clearInterval(this.keepAliveInterval);
@@ -375,7 +375,7 @@ export class StreamSfuClient {
       await this.joinTask;
       await this.notifyLeave(reason);
     } catch (err) {
-      this.logger('debug', 'Error notifying SFU about leaving call', err);
+      this.logger.debug('Error notifying SFU about leaving call', err);
     }
 
     this.close(StreamSfuClient.NORMAL_CLOSURE, reason.substring(0, 115));
@@ -557,10 +557,10 @@ export class StreamSfuClient {
     await this.signalReady(); // wait for the signal ws to be open
     const msgJson = SfuRequest.toJson(message);
     if (this.signalWs.readyState !== WebSocket.OPEN) {
-      this.logger('debug', 'Signal WS is not open. Skipping message', msgJson);
+      this.logger.debug('Signal WS is not open. Skipping message', msgJson);
       return;
     }
-    this.logger('debug', `Sending message to: ${this.edgeName}`, msgJson);
+    this.logger.debug(`Sending message to: ${this.edgeName}`, msgJson);
     this.signalWs.send(SfuRequest.toBinary(message));
   };
 
@@ -569,7 +569,7 @@ export class StreamSfuClient {
     timers.clearInterval(this.keepAliveInterval);
     this.keepAliveInterval = timers.setInterval(() => {
       this.ping().catch((e) => {
-        this.logger('error', 'Error sending healthCheckRequest to SFU', e);
+        this.logger.error('Error sending healthCheckRequest to SFU', e);
       });
     }, this.pingIntervalInMs);
   };

package/src/StreamVideoClient.ts

@@ -24,7 +24,6 @@ import type {
 import {
   AllClientEvents,
   ClientEventListener,
-  Logger,
   StreamClientOptions,
   TokenOrProvider,
   TokenProvider,
@@ -38,7 +37,7 @@ import {
   getCallInitConcurrencyTag,
   getInstanceKey,
 } from './helpers/clientUtils';
-import { getLogger, logToConsole, setLogger } from './logger';
+import { logToConsole, ScopedLogger, videoLoggerSystem } from './logger';
 import { withoutConcurrency } from './helpers/concurrency';
 import { enableTimerWorker } from './timers';
 
@@ -63,7 +62,7 @@ export class StreamVideoClient {
    * @deprecated use the `client.state` getter.
    */
   readonly readOnlyStateStore: StreamVideoReadOnlyStateStore;
-  readonly logger: Logger;
+  readonly logger: ScopedLogger;
 
   protected readonly writeableStateStore: StreamVideoWriteableStateStore;
   streamClient: StreamClient;
@@ -94,9 +93,13 @@ export class StreamVideoClient {
     if (clientOptions?.enableTimerWorker) enableTimerWorker();
 
     const rootLogger = clientOptions?.logger || logToConsole;
-    setLogger(rootLogger, clientOptions?.logLevel || 'warn');
 
-    this.logger = getLogger(['client']);
+    videoLoggerSystem.configureLoggers({
+      default: { sink: rootLogger, level: clientOptions?.logLevel || 'warn' },
+      ...clientOptions?.logOptions,
+    });
+
+    this.logger = videoLoggerSystem.getLogger('client');
     this.rejectCallWhenBusy = clientOptions?.rejectCallWhenBusy ?? false;
 
     this.streamClient = createCoordinatorClient(apiKey, clientOptions);
@@ -113,7 +116,7 @@ export class StreamVideoClient {
 
       const tokenOrProvider = createTokenOrProvider(apiKeyOrArgs);
       this.connectUser(user, tokenOrProvider).catch((err) => {
-        this.logger('error', 'Failed to connect', err);
+        this.logger.error('Failed to connect', err);
       });
     }
   }
@@ -149,8 +152,7 @@ export class StreamVideoClient {
   private registerClientInstance = (apiKey: string, user: User) => {
     const instanceKey = getInstanceKey(apiKey, user);
     if (StreamVideoClient._instances.has(instanceKey)) {
-      this.logger(
-        'warn',
+      this.logger.warn(
         `A StreamVideoClient already exists for ${user.id}; Prefer using getOrCreateInstance method`,
       );
     }
@@ -178,13 +180,13 @@ export class StreamVideoClient {
           .map((call) => call.cid);
         if (callsToReWatch.length <= 0) return;
 
-        this.logger('info', `Rewatching calls ${callsToReWatch.join(', ')}`);
+        this.logger.info(`Rewatching calls ${callsToReWatch.join(', ')}`);
         this.queryCalls({
           watch: true,
           filter_conditions: { cid: { $in: callsToReWatch } },
           sort: [{ field: 'cid', direction: 1 }],
         }).catch((err) => {
-          this.logger('error', 'Failed to re-watch calls', err);
+          this.logger.error('Failed to re-watch calls', err);
         });
       }),
     );
@@ -198,7 +200,7 @@ export class StreamVideoClient {
    */
   private initCallFromEvent = async (e: CallCreatedEvent | CallRingEvent) => {
     if (this.state.connectedUser?.id === e.call.created_by.id) {
-      this.logger('debug', `Ignoring ${e.type} event sent by the current user`);
+      this.logger.debug(`Ignoring ${e.type} event sent by the current user`);
       return;
     }
 
@@ -210,8 +212,7 @@ export class StreamVideoClient {
         if (call) {
           if (ringing) {
             if (this.shouldRejectCall(call.cid)) {
-              this.logger(
-                'info',
+              this.logger.info(
                 `Leaving call with busy reject reason ${call.cid} because user is busy`,
               );
               // remove the instance from the state store
@@ -238,10 +239,7 @@ export class StreamVideoClient {
 
         if (ringing) {
           if (this.shouldRejectCall(call.cid)) {
-            this.logger(
-              'info',
-              `Rejecting call ${call.cid} because user is busy`,
-            );
+            this.logger.info(`Rejecting call ${call.cid} because user is busy`);
             // call is not in the state store yet, so just reject api is enough
             await call.reject('busy');
           } else {
@@ -251,11 +249,11 @@ export class StreamVideoClient {
         } else {
           call.state.updateFromCallResponse(e.call);
           this.writeableStateStore.registerCall(call);
-          this.logger('info', `New call created and registered: ${call.cid}`);
+          this.logger.info(`New call created and registered: ${call.cid}`);
         }
       });
     } catch (err) {
-      this.logger('error', `Failed to init call from event ${e.type}`, err);
+      this.logger.error(`Failed to init call from event ${e.type}`, err);
     }
   };
 
@@ -288,12 +286,12 @@ export class StreamVideoClient {
         const errorQueue: Error[] = [];
         for (let attempt = 0; attempt < maxConnectUserRetries; attempt++) {
           try {
-            this.logger('trace', `Connecting user (${attempt})`, user);
+            this.logger.trace(`Connecting user (${attempt})`, user);
             return user.type === 'guest'
               ? await client.connectGuestUser(user)
               : await client.connectUser(user, tokenOrProvider);
           } catch (err) {
-            this.logger('warn', `Failed to connect a user (${attempt})`, err);
+            this.logger.warn(`Failed to connect a user (${attempt})`, err);
             errorQueue.push(err as Error);
             if (attempt === maxConnectUserRetries - 1) {
               onConnectUserError?.(err as Error, errorQueue);