@stream-io/video-client 1.18.9 → 1.19.0

package/src/Call.ts

@@ -115,7 +115,13 @@ import {
   TrackType,
   WebsocketReconnectStrategy,
 } from './gen/video/sfu/models/models';
-import { createStatsReporter, SfuStatsReporter, StatsReporter } from './stats';
+import {
+  createStatsReporter,
+  getSdkSignature,
+  SfuStatsReporter,
+  StatsReporter,
+} from './stats';
+import { tracer as mediaStatsTracer } from './stats/rtc/mediaDevices';
 import { DynascaleManager } from './helpers/DynascaleManager';
 import { PermissionsContext } from './permissions';
 import { CallTypes } from './CallType';
@@ -137,7 +143,6 @@ import {
   ScreenShareManager,
   SpeakerManager,
 } from './devices';
-import { getSdkSignature } from './stats/utils';
 import { hasPending, withoutConcurrency } from './helpers/concurrency';
 import { ensureExhausted } from './helpers/ensureExhausted';
 import { pushToIfMissing } from './helpers/array';
@@ -236,6 +241,7 @@ export class Call {
   private readonly reconnectConcurrencyTag = Symbol('reconnectConcurrencyTag');
   private reconnectAttempts = 0;
   private reconnectStrategy = WebsocketReconnectStrategy.UNSPECIFIED;
+  private reconnectReason = '';
   private fastReconnectDeadlineSeconds: number = 0;
   private disconnectionTimeoutSeconds: number = 0;
   private lastOfflineTimestamp: number = 0;
@@ -898,14 +904,16 @@ export class Call {
     const sfuClient =
       performingRejoin || performingMigration || !isWsHealthy
         ? new StreamSfuClient({
-            logTag: String(this.sfuClientTag++),
+            logTag: String(++this.sfuClientTag),
             dispatcher: this.dispatcher,
             credentials: this.credentials,
             streamClient: this.streamClient,
+            enableTracing: statsOptions.enable_rtc_stats,
             // a new session_id is necessary for the REJOIN strategy.
             // we use the previous session_id if available
             sessionId: performingRejoin ? undefined : previousSessionId,
-            onSignalClose: () => this.handleSfuSignalClose(sfuClient),
+            onSignalClose: (reason) =>
+              this.handleSfuSignalClose(sfuClient, reason),
           })
         : previousSfuClient;
     this.sfuClient = sfuClient;
@@ -1024,6 +1032,7 @@ export class Call {
     delete this.joinCallData?.notify;
     // reset the reconnect strategy to unspecified after a successful reconnection
     this.reconnectStrategy = WebsocketReconnectStrategy.UNSPECIFIED;
+    this.reconnectReason = '';
 
     this.logger('info', `Joined call ${this.cid}`);
   };
@@ -1047,6 +1056,7 @@ export class Call {
       reconnectAttempt: this.reconnectAttempts,
       fromSfuId: migratingFromSfuId || '',
       previousSessionId: performingRejoin ? previousSessionId || '' : '',
+      reason: this.reconnectReason,
     };
   };
 
@@ -1155,6 +1165,7 @@ export class Call {
       publishOptions,
       closePreviousInstances,
     } = opts;
+    const { enable_rtc_stats: enableTracing } = statsOptions;
     if (closePreviousInstances && this.subscriber) {
       this.subscriber.dispose();
     }
@@ -1164,14 +1175,17 @@ export class Call {
       state: this.state,
       connectionConfig,
       logTag: String(this.sfuClientTag),
-      onUnrecoverableError: () => {
-        this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
-          this.logger(
-            'warn',
-            '[Reconnect] Error reconnecting after a subscriber error',
-            err,
-          );
-        });
+      enableTracing,
+      onUnrecoverableError: (reason) => {
+        this.reconnect(WebsocketReconnectStrategy.REJOIN, reason).catch(
+          (err) => {
+            this.logger(
+              'warn',
+              `[Reconnect] Error reconnecting after a subscriber error: ${reason}`,
+              err,
+            );
+          },
+        );
       },
     });
 
@@ -1189,18 +1203,22 @@ export class Call {
         connectionConfig,
         publishOptions,
         logTag: String(this.sfuClientTag),
-        onUnrecoverableError: () => {
-          this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
-            this.logger(
-              'warn',
-              '[Reconnect] Error reconnecting after a publisher error',
-              err,
-            );
-          });
+        enableTracing,
+        onUnrecoverableError: (reason) => {
+          this.reconnect(WebsocketReconnectStrategy.REJOIN, reason).catch(
+            (err) => {
+              this.logger(
+                'warn',
+                `[Reconnect] Error reconnecting after a publisher error: ${reason}`,
+                err,
+              );
+            },
+          );
         },
       });
     }
 
+    mediaStatsTracer.setEnabled(enableTracing);
     this.statsReporter?.stop();
     this.statsReporter = createStatsReporter({
       subscriber: this.subscriber,
@@ -1267,8 +1285,12 @@ export class Call {
    *
    * @internal
    * @param sfuClient the SFU client instance that was closed.
+   * @param reason the reason for the closure.
    */
-  private handleSfuSignalClose = (sfuClient: StreamSfuClient) => {
+  private handleSfuSignalClose = (
+    sfuClient: StreamSfuClient,
+    reason: string,
+  ) => {
     this.logger('debug', '[Reconnect] SFU signal connection closed');
     const { callingState } = this.state;
     if (
@@ -1286,7 +1308,7 @@ export class Call {
       return;
     // normal close, no need to reconnect
     if (sfuClient.isLeaving) return;
-    this.reconnect(WebsocketReconnectStrategy.REJOIN).catch((err) => {
+    this.reconnect(WebsocketReconnectStrategy.REJOIN, reason).catch((err) => {
       this.logger('warn', '[Reconnect] Error reconnecting', err);
     });
   };
@@ -1297,9 +1319,11 @@ export class Call {
    * @internal
    *
    * @param strategy the reconnection strategy to use.
+   * @param reason the reason for the reconnection.
    */
   private reconnect = async (
     strategy: WebsocketReconnectStrategy,
+    reason: string,
   ): Promise<void> => {
     if (
       this.state.callingState === CallingState.RECONNECTING ||
@@ -1315,6 +1339,7 @@ export class Call {
 
       const reconnectStartTime = Date.now();
       this.reconnectStrategy = strategy;
+      this.reconnectReason = reason;
 
       do {
         if (
@@ -1475,7 +1500,7 @@ export class Call {
       currentPublisher?.dispose();
 
       // and close the previous SFU client, without specifying close code
-      currentSfuClient.close();
+      currentSfuClient.close(StreamSfuClient.NORMAL_CLOSURE, 'Migrating away');
     }
     this.sfuStatsReporter?.sendReconnectionTime(
       WebsocketReconnectStrategy.MIGRATE,
@@ -1491,21 +1516,21 @@ export class Call {
   private registerReconnectHandlers = () => {
     // handles the legacy "goAway" event
     const unregisterGoAway = this.on('goAway', () => {
-      this.reconnect(WebsocketReconnectStrategy.MIGRATE).catch((err) => {
-        this.logger('warn', '[Reconnect] Error reconnecting', err);
-      });
+      this.reconnect(WebsocketReconnectStrategy.MIGRATE, 'goAway').catch(
+        (err) => this.logger('warn', '[Reconnect] Error reconnecting', err),
+      );
     });
 
     // handles the "error" event, through which the SFU can request a reconnect
     const unregisterOnError = this.on('error', (e) => {
-      const { reconnectStrategy: strategy } = e;
+      const { reconnectStrategy: strategy, error } = e;
       if (strategy === WebsocketReconnectStrategy.UNSPECIFIED) return;
       if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
         this.leave({ reason: 'SFU instructed to disconnect' }).catch((err) => {
           this.logger('warn', `Can't leave call after disconnect request`, err);
         });
       } else {
-        this.reconnect(strategy).catch((err) => {
+        this.reconnect(strategy, error?.message || 'SFU Error').catch((err) => {
           this.logger('warn', '[Reconnect] Error reconnecting', err);
         });
       }
@@ -1531,7 +1556,7 @@ export class Call {
               }
             }
 
-            this.reconnect(strategy).catch((err) => {
+            this.reconnect(strategy, 'Going online').catch((err) => {
               this.logger(
                 'warn',
                 '[Reconnect] Error reconnecting after going online',

package/src/StreamSfuClient.ts

@@ -4,6 +4,7 @@ import {
   retryable,
   withHeaders,
   withRequestLogger,
+  withRequestTracer,
 } from './rpc';
 import {
   createWebSocketSignalChannel,
@@ -36,6 +37,7 @@ import {
   SafePromise,
 } from './helpers/promise';
 import { getTimers } from './timers';
+import { Tracer, TraceSlice } from './stats';
 
 export type StreamSfuClientConstructor = {
   /**
@@ -67,12 +69,17 @@ export type StreamSfuClientConstructor = {
   /**
    * Callback for when the WebSocket connection is closed.
    */
-  onSignalClose?: () => void;
+  onSignalClose?: (reason: string) => void;
 
   /**
    * The StreamClient instance to use for the connection.
    */
   streamClient: StreamClient;
+
+  /**
+   * Flag to enable tracing.
+   */
+  enableTracing: boolean;
 };
 
 /**
@@ -118,9 +125,10 @@ export class StreamSfuClient {
   private pingIntervalInMs = 10 * 1000;
   private unhealthyTimeoutInMs = this.pingIntervalInMs + 5 * 1000;
   private lastMessageTimestamp?: Date;
+  private readonly tracer?: Tracer;
   private readonly unsubscribeIceTrickle: () => void;
   private readonly unsubscribeNetworkChanged: () => void;
-  private readonly onSignalClose: (() => void) | undefined;
+  private readonly onSignalClose: ((reason: string) => void) | undefined;
   private readonly logger: Logger;
   private readonly logTag: string;
   private readonly credentials: Credentials;
@@ -173,6 +181,7 @@ export class StreamSfuClient {
     joinResponseTimeout = 5000,
     onSignalClose,
     streamClient,
+    enableTracing,
   }: StreamSfuClientConstructor) {
     this.dispatcher = dispatcher;
     this.sessionId = sessionId || generateUUIDv4();
@@ -183,12 +192,12 @@ export class StreamSfuClient {
     this.joinResponseTimeout = joinResponseTimeout;
     this.logTag = logTag;
     this.logger = getLogger(['SfuClient', logTag]);
+    this.tracer = enableTracing ? new Tracer(logTag) : undefined;
     this.rpc = createSignalClient({
       baseUrl: server.url,
       interceptors: [
-        withHeaders({
-          Authorization: `Bearer ${token}`,
-        }),
+        withHeaders({ Authorization: `Bearer ${token}` }),
+        this.tracer && withRequestTracer(this.tracer.trace),
         getLogLevel() === 'trace' && withRequestLogger(this.logger, 'trace'),
       ].filter((v) => !!v),
     });
@@ -237,8 +246,8 @@ export class StreamSfuClient {
 
           this.signalWs.addEventListener('open', onOpen);
 
-          this.signalWs.addEventListener('close', () => {
-            this.handleWebSocketClose();
+          this.signalWs.addEventListener('close', (e) => {
+            this.handleWebSocketClose(e);
             // Normally, this shouldn't have any effect, because WS should never emit 'close'
             // before emitting 'open'. However, strager things have happened, and we don't
             // want to leave signalReady in pending state.
@@ -271,11 +280,11 @@ export class StreamSfuClient {
     return this.joinResponseTask.promise;
   }
 
-  private handleWebSocketClose = () => {
+  private handleWebSocketClose = (e: CloseEvent) => {
     this.signalWs.removeEventListener('close', this.handleWebSocketClose);
     getTimers().clearInterval(this.keepAliveInterval);
     clearTimeout(this.connectionCheckTimeout);
-    this.onSignalClose?.();
+    this.onSignalClose?.(`${e.code} ${e.reason}`);
   };
 
   close = (code: number = StreamSfuClient.NORMAL_CLOSURE, reason?: string) => {
@@ -299,6 +308,10 @@ export class StreamSfuClient {
     this.iceTrickleBuffer.dispose();
   };
 
+  getTrace = (): TraceSlice | undefined => {
+    return this.tracer?.take();
+  };
+
   leaveAndClose = async (reason: string) => {
     await this.joinTask;
     try {

package/src/gen/coordinator/index.ts

@@ -726,6 +726,178 @@ export interface CallEvent {
    */
   type: string;
 }
+/**
+ * This event is sent when frame recording has failed
+ * @export
+ * @interface CallFrameRecordingFailedEvent
+ */
+export interface CallFrameRecordingFailedEvent {
+  /**
+   *
+   * @type {CallResponse}
+   * @memberof CallFrameRecordingFailedEvent
+   */
+  call: CallResponse;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingFailedEvent
+   */
+  call_cid: string;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingFailedEvent
+   */
+  created_at: string;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingFailedEvent
+   */
+  egress_id: string;
+  /**
+   * The type of event: "call.frame_recording_failed" in this case
+   * @type {string}
+   * @memberof CallFrameRecordingFailedEvent
+   */
+  type: string;
+}
+/**
+ * This event is sent when a frame is captured from a call
+ * @export
+ * @interface CallFrameRecordingFrameReadyEvent
+ */
+export interface CallFrameRecordingFrameReadyEvent {
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingFrameReadyEvent
+   */
+  call_cid: string;
+  /**
+   * The time the frame was captured
+   * @type {string}
+   * @memberof CallFrameRecordingFrameReadyEvent
+   */
+  captured_at: string;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingFrameReadyEvent
+   */
+  created_at: string;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingFrameReadyEvent
+   */
+  egress_id: string;
+  /**
+   * Call session ID
+   * @type {string}
+   * @memberof CallFrameRecordingFrameReadyEvent
+   */
+  session_id: string;
+  /**
+   * The type of the track frame was captured from (TRACK_TYPE_VIDEO|TRACK_TYPE_SCREEN_SHARE)
+   * @type {string}
+   * @memberof CallFrameRecordingFrameReadyEvent
+   */
+  track_type: string;
+  /**
+   * The type of event: "call.frame_recording_ready" in this case
+   * @type {string}
+   * @memberof CallFrameRecordingFrameReadyEvent
+   */
+  type: string;
+  /**
+   * The URL of the frame
+   * @type {string}
+   * @memberof CallFrameRecordingFrameReadyEvent
+   */
+  url: string;
+  /**
+   * The users in the frame
+   * @type {{ [key: string]: UserResponse; }}
+   * @memberof CallFrameRecordingFrameReadyEvent
+   */
+  users: { [key: string]: UserResponse };
+}
+/**
+ * This event is sent when frame recording has started
+ * @export
+ * @interface CallFrameRecordingStartedEvent
+ */
+export interface CallFrameRecordingStartedEvent {
+  /**
+   *
+   * @type {CallResponse}
+   * @memberof CallFrameRecordingStartedEvent
+   */
+  call: CallResponse;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingStartedEvent
+   */
+  call_cid: string;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingStartedEvent
+   */
+  created_at: string;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingStartedEvent
+   */
+  egress_id: string;
+  /**
+   * The type of event: "call.frame_recording_started" in this case
+   * @type {string}
+   * @memberof CallFrameRecordingStartedEvent
+   */
+  type: string;
+}
+/**
+ * This event is sent when frame recording has stopped
+ * @export
+ * @interface CallFrameRecordingStoppedEvent
+ */
+export interface CallFrameRecordingStoppedEvent {
+  /**
+   *
+   * @type {CallResponse}
+   * @memberof CallFrameRecordingStoppedEvent
+   */
+  call: CallResponse;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingStoppedEvent
+   */
+  call_cid: string;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingStoppedEvent
+   */
+  created_at: string;
+  /**
+   *
+   * @type {string}
+   * @memberof CallFrameRecordingStoppedEvent
+   */
+  egress_id: string;
+  /**
+   * The type of event: "call.frame_recording_stopped" in this case
+   * @type {string}
+   * @memberof CallFrameRecordingStoppedEvent
+   */
+  type: string;
+}
 /**
  * This event is sent when HLS broadcasting has failed
  * @export
@@ -1221,6 +1393,12 @@ export interface CallRecording {
    * @memberof CallRecording
    */
   filename: string;
+  /**
+   *
+   * @type {string}
+   * @memberof CallRecording
+   */
+  session_id: string;
   /**
    *
    * @type {string}
@@ -1389,7 +1567,7 @@ export interface CallRejectedEvent {
    */
   created_at: string;
   /**
-   *
+   * Provides information about why the call was rejected. You can provide any value, but the Stream API and SDKs use these default values: rejected, cancel, timeout and busy
    * @type {string}
    * @memberof CallRejectedEvent
    */
@@ -3286,6 +3464,12 @@ export interface EgressResponse {
    * @memberof EgressResponse
    */
   broadcasting: boolean;
+  /**
+   *
+   * @type {FrameRecordingResponse}
+   * @memberof EgressResponse
+   */
+  frame_recording?: FrameRecordingResponse;
   /**
    *
    * @type {EgressHLSResponse}
@@ -3312,6 +3496,38 @@ export interface EndCallResponse {
    */
   duration: string;
 }
+/**
+ *
+ * @export
+ * @interface FPSStats
+ */
+export interface FPSStats {
+  /**
+   *
+   * @type {number}
+   * @memberof FPSStats
+   */
+  average_fps: number;
+  /**
+   *
+   * @type {number}
+   * @memberof FPSStats
+   */
+  tracked: number;
+}
+/**
+ *
+ * @export
+ * @interface FrameRecordingResponse
+ */
+export interface FrameRecordingResponse {
+  /**
+   *
+   * @type {string}
+   * @memberof FrameRecordingResponse
+   */
+  status: string;
+}
 /**
  *
  * @export
@@ -3335,7 +3551,7 @@ export interface FrameRecordingSettingsRequest {
    * @type {string}
    * @memberof FrameRecordingSettingsRequest
    */
-  quality?: string;
+  quality?: FrameRecordingSettingsRequestQualityEnum;
 }
 
 /**
@@ -3349,6 +3565,19 @@ export const FrameRecordingSettingsRequestModeEnum = {
 export type FrameRecordingSettingsRequestModeEnum =
   (typeof FrameRecordingSettingsRequestModeEnum)[keyof typeof FrameRecordingSettingsRequestModeEnum];
 
+/**
+ * @export
+ */
+export const FrameRecordingSettingsRequestQualityEnum = {
+  _360P: '360p',
+  _480P: '480p',
+  _720P: '720p',
+  _1080P: '1080p',
+  _1440P: '1440p',
+} as const;
+export type FrameRecordingSettingsRequestQualityEnum =
+  (typeof FrameRecordingSettingsRequestQualityEnum)[keyof typeof FrameRecordingSettingsRequestQualityEnum];
+
 /**
  *
  * @export
@@ -3558,6 +3787,12 @@ export interface GetCallStatsResponse {
    * @memberof GetCallStatsResponse
    */
   duration: string;
+  /**
+   *
+   * @type {boolean}
+   * @memberof GetCallStatsResponse
+   */
+  is_truncated_report: boolean;
   /**
    *
    * @type {TimeStats}
@@ -5381,19 +5616,19 @@ export interface Response {
  */
 export interface RingSettingsRequest {
   /**
-   *
+   * When none of the callees accept a ring call in this time a rejection will be sent by the caller with reason 'timeout' by the SDKs
    * @type {number}
    * @memberof RingSettingsRequest
    */
   auto_cancel_timeout_ms: number;
   /**
-   *
+   * When a callee is online but doesn't answer a ring call in this time a rejection will be sent with reason 'timeout' by the SDKs
    * @type {number}
    * @memberof RingSettingsRequest
    */
   incoming_call_timeout_ms: number;
   /**
-   *
+   * When a callee doesn't accept or reject a ring call in this time a missed call event will be sent
    * @type {number}
    * @memberof RingSettingsRequest
    */
@@ -5850,6 +6085,12 @@ export interface StartTranscriptionResponse {
  * @interface StatsOptions
  */
 export interface StatsOptions {
+  /**
+   *
+   * @type {boolean}
+   * @memberof StatsOptions
+   */
+  enable_rtc_stats: boolean;
   /**
    *
    * @type {number}
@@ -6972,6 +7213,12 @@ export interface UserSessionStats {
    * @memberof UserSessionStats
    */
   distance_to_sfu_kilometers?: number;
+  /**
+   *
+   * @type {FPSStats}
+   * @memberof UserSessionStats
+   */
+  fps?: FPSStats;
   /**
    *
    * @type {number}
@@ -7245,6 +7492,12 @@ export interface UserSessionStats {
  * @interface UserStats
  */
 export interface UserStats {
+  /**
+   *
+   * @type {string}
+   * @memberof UserStats
+   */
+  feedback?: string;
   /**
    *
    * @type {UserInfoResponse}
@@ -7341,6 +7594,10 @@ export type VideoEvent =
   | ({ type: 'call.created' } & CallCreatedEvent)
   | ({ type: 'call.deleted' } & CallDeletedEvent)
   | ({ type: 'call.ended' } & CallEndedEvent)
+  | ({ type: 'call.frame_recording_failed' } & CallFrameRecordingFailedEvent)
+  | ({ type: 'call.frame_recording_ready' } & CallFrameRecordingFrameReadyEvent)
+  | ({ type: 'call.frame_recording_started' } & CallFrameRecordingStartedEvent)
+  | ({ type: 'call.frame_recording_stopped' } & CallFrameRecordingStoppedEvent)
   | ({ type: 'call.hls_broadcasting_failed' } & CallHLSBroadcastingFailedEvent)
   | ({
       type: 'call.hls_broadcasting_started';