@stream-io/video-client 1.35.1 → 1.36.1

package/src/rtc/signal.ts

@@ -1,7 +1,7 @@
 import { SfuEvent } from '../gen/video/sfu/event/events';
-import { getLogger } from '../logger';
 import { DispatchableMessage, SfuEventKinds } from './Dispatcher';
 import { Tracer } from '../stats';
+import { videoLoggerSystem } from '../logger';
 
 export const createWebSocketSignalChannel = (opts: {
   endpoint: string;
@@ -10,23 +10,23 @@ export const createWebSocketSignalChannel = (opts: {
   tracer: Tracer | undefined;
 }) => {
   const { endpoint, onMessage, tag, tracer } = opts;
-  const logger = getLogger(['SfuClientWS', tag]);
-  logger('debug', 'Creating signaling WS channel:', endpoint);
+  const logger = videoLoggerSystem.getLogger('SfuClientWS', { tags: [tag] });
+  logger.debug('Creating signaling WS channel:', endpoint);
   const ws = new WebSocket(endpoint);
   ws.binaryType = 'arraybuffer'; // do we need this?
 
   ws.addEventListener('error', (e) => {
-    logger('error', 'Signaling WS channel error', e);
+    logger.error('Signaling WS channel error', e);
     tracer?.trace('signal.ws.error', e);
   });
 
   ws.addEventListener('close', (e) => {
-    logger('info', 'Signaling WS channel is closed', e);
+    logger.info('Signaling WS channel is closed', e);
     tracer?.trace('signal.ws.close', e);
   });
 
   ws.addEventListener('open', (e) => {
-    logger('info', 'Signaling WS channel is open', e);
+    logger.info('Signaling WS channel is open', e);
     tracer?.trace('signal.ws.open', e);
   });
 
@@ -41,7 +41,7 @@ export const createWebSocketSignalChannel = (opts: {
     } catch (err) {
       const message =
         'Failed to decode a message. Check whether the Proto models match.';
-      logger('error', message, { event: e, error: err });
+      logger.error(message, { event: e, error: err });
       tracer?.trace('signal.ws.message.error', message);
     }
   });

package/src/rtc/types.ts

@@ -1,5 +1,6 @@
 import {
   AudioBitrateProfile,
+  PeerType,
   PublishOption,
   WebsocketReconnectStrategy,
 } from '../gen/video/sfu/models/models';
@@ -7,10 +8,12 @@ import { StreamSfuClient } from '../StreamSfuClient';
 import { CallState } from '../store';
 import { Dispatcher } from './Dispatcher';
 import type { OptimalVideoLayer } from './layers';
+import type { ClientPublishOptions } from '../types';
 
 export type OnReconnectionNeeded = (
   kind: WebsocketReconnectStrategy,
   reason: string,
+  peerType: PeerType,
 ) => void;
 
 export type BasePeerConnectionOpts = {
@@ -22,10 +25,7 @@ export type BasePeerConnectionOpts = {
   tag: string;
   enableTracing: boolean;
   iceRestartDelay?: number;
-};
-
-export type PublisherConstructorOpts = BasePeerConnectionOpts & {
-  publishOptions: PublishOption[];
+  clientPublishOptions?: ClientPublishOptions;
 };
 
 export type TrackPublishOptions = {

package/src/stats/CallStateStatsReporter.ts

@@ -8,10 +8,10 @@ import type {
 } from './types';
 import { CallState } from '../store';
 import { Publisher, Subscriber } from '../rtc';
-import { getLogger } from '../logger';
 import { flatten } from './utils';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { isFirefox } from '../helpers/browsers';
+import { videoLoggerSystem } from '../logger';
 
 export type StatsReporterOpts = {
   subscriber: Subscriber;
@@ -77,7 +77,7 @@ export const createStatsReporter = ({
   datacenter,
   pollingIntervalInMs = 2000,
 }: StatsReporterOpts): StatsReporter => {
-  const logger = getLogger(['stats']);
+  const logger = videoLoggerSystem.getLogger('stats');
   const getRawStatsForTrack = async (
     kind: PeerConnectionKind,
     selector?: MediaStreamTrack,
@@ -148,7 +148,7 @@ export const createStatsReporter = ({
               ];
           participantStats[sessionId] = await getStatsForStream(kind, tracks);
         } catch (e) {
-          logger('warn', `Failed to collect ${kind} stats for ${userId}`, e);
+          logger.warn(`Failed to collect ${kind} stats for ${userId}`, e);
         }
       }
     }
@@ -186,7 +186,7 @@ export const createStatsReporter = ({
       // (they are expensive) if no one is listening to them
       if (state.isCallStatsReportObserved) {
         await run().catch((e) => {
-          logger('debug', 'Failed to collect stats', e);
+          logger.debug('Failed to collect stats', e);
         });
       }
       timeoutId = setTimeout(loop, pollingIntervalInMs);

package/src/stats/SfuStatsReporter.ts

@@ -1,7 +1,6 @@
 import { combineLatest } from 'rxjs';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { OwnCapability, StatsOptions } from '../gen/coordinator';
-import { getLogger } from '../logger';
 import { Publisher, Subscriber } from '../rtc';
 import { Tracer, TraceRecord } from './rtc';
 import { flatten, getSdkName, getSdkVersion } from './utils';
@@ -15,6 +14,7 @@ import { CameraManager, MicrophoneManager } from '../devices';
 import { createSubscription } from '../store/rxUtils';
 import { CallState } from '../store';
 import { Telemetry } from '../gen/video/sfu/signal_rpc/signal';
+import { videoLoggerSystem } from '../logger';
 
 export type SfuStatsReporterOptions = {
   options: StatsOptions;
@@ -29,7 +29,7 @@ export type SfuStatsReporterOptions = {
 };
 
 export class SfuStatsReporter {
-  private readonly logger = getLogger(['SfuStatsReporter']);
+  private readonly logger = videoLoggerSystem.getLogger('SfuStatsReporter');
 
   readonly options: StatsOptions;
 
@@ -153,7 +153,7 @@ export class SfuStatsReporter {
     // intentionally not awaiting the promise here
     // to avoid impeding with the ongoing actions.
     this.run(telemetryData).catch((err) => {
-      this.logger('warn', 'Failed to send telemetry data', err);
+      this.logger.warn('Failed to send telemetry data', err);
     });
   };
 
@@ -217,7 +217,7 @@ export class SfuStatsReporter {
     clearInterval(this.intervalId);
     this.intervalId = setInterval(() => {
       this.run().catch((err) => {
-        this.logger('warn', 'Failed to report stats', err);
+        this.logger.warn('Failed to report stats', err);
       });
     }, this.options.reporting_interval_ms);
   };
@@ -237,7 +237,7 @@ export class SfuStatsReporter {
 
   flush = () => {
     this.run().catch((err) => {
-      this.logger('warn', 'Failed to flush report stats', err);
+      this.logger.warn('Failed to flush report stats', err);
     });
   };
 
@@ -245,7 +245,7 @@ export class SfuStatsReporter {
     clearTimeout(this.timeoutId);
     this.timeoutId = setTimeout(() => {
       this.run().catch((err) => {
-        this.logger('warn', 'Failed to report stats', err);
+        this.logger.warn('Failed to report stats', err);
       });
     }, timeout);
   };

package/src/store/CallState.ts

@@ -55,8 +55,8 @@ import {
   CallGrants,
 } from '../gen/video/sfu/models/models';
 import { Comparator, defaultSortPreset } from '../sorting';
-import { getLogger } from '../logger';
 import { hasScreenShare } from '../helpers/participantUtils';
+import { videoLoggerSystem } from '../logger';
 
 /**
  * Returns the default egress object - when no egress data is available.
@@ -312,7 +312,7 @@ export class CallState {
    */
   closedCaptions$: Observable<CallClosedCaption[]>;
 
-  readonly logger = getLogger(['CallState']);
+  readonly logger = videoLoggerSystem.getLogger('CallState');
 
   /**
    * A list of comparators that are used to sort the participants.
@@ -997,7 +997,7 @@ export class CallState {
   ) => {
     const participant = this.findParticipantBySessionId(sessionId);
     if (!participant) {
-      this.logger('warn', `Participant with sessionId ${sessionId} not found`);
+      this.logger.warn(`Participant with sessionId ${sessionId} not found`);
       return;
     }
 

package/src/store/rxUtils.ts

@@ -1,6 +1,6 @@
 import { BehaviorSubject, combineLatest, Observable, Subject } from 'rxjs';
 import { withoutConcurrency } from '../helpers/concurrency';
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 type FunctionPatch<T> = (currentValue: T) => T;
 
@@ -92,7 +92,9 @@ export const createSubscription = <T>(
   observable: Observable<T>,
   handler: (value: T) => void,
   onError: (error: any) => void = (error) =>
-    getLogger(['RxUtils'])('warn', 'An observable emitted an error', error),
+    videoLoggerSystem
+      .getLogger('RxUtils')
+      .warn('An observable emitted an error', error),
 ) => {
   const subscription = observable.subscribe({ next: handler, error: onError });
   return () => {

package/src/store/stateStore.ts

@@ -4,7 +4,7 @@ import * as RxUtils from './rxUtils';
 import { Call } from '../Call';
 import { CallingState } from './CallingState';
 import type { OwnUserResponse } from '../gen/coordinator';
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 export class StreamVideoWriteableStateStore {
   /**
@@ -23,15 +23,15 @@ export class StreamVideoWriteableStateStore {
     this.connectedUserSubject.subscribe(async (user) => {
       // leave all calls when the user disconnects.
       if (!user) {
-        const logger = getLogger(['client-state']);
+        const logger = videoLoggerSystem.getLogger('client-state');
         for (const call of this.calls) {
           if (call.state.callingState === CallingState.LEFT) continue;
 
-          logger('info', `User disconnected, leaving call: ${call.cid}`);
+          logger.info(`User disconnected, leaving call: ${call.cid}`);
           await call
             .leave({ message: 'client.disconnectUser() called' })
             .catch((err) => {
-              logger('error', `Error leaving call: ${call.cid}`, err);
+              logger.error(`Error leaving call: ${call.cid}`, err);
             });
         }
       }
@@ -87,8 +87,8 @@ export class StreamVideoWriteableStateStore {
    * @param call the call to remove
    */
   unregisterCall = (call: Call) => {
-    const logger = getLogger(['client-state']);
-    logger('trace', `Unregistering call: ${call.cid}`);
+    const logger = videoLoggerSystem.getLogger('client-state');
+    logger.trace(`Unregistering call: ${call.cid}`);
     return this.setCalls((calls) => calls.filter((c) => c !== call));
   };
 

package/src/types.ts

@@ -212,6 +212,12 @@ export type ClientPublishOptions = {
    * Screen share settings.
    */
   screenShareSettings?: ScreenShareSettings;
+  /**
+   * Forces a specific codec to be used when publishing and subscribing a video stream.
+   * Never use it in production as it can have unforeseeable consequences.
+   * @internal
+   */
+  dangerouslyForceCodec?: PreferredCodec;
 };
 
 export type ScreenShareSettings = {