@stream-io/video-client 0.0.28 → 0.0.29

package/src/StreamSfuClient.ts

@@ -1,3 +1,4 @@
+import type { WebSocket } from 'ws';
 import type {
   FinishedUnaryCall,
   MethodInfo,
@@ -30,6 +31,7 @@ import {
   retryInterval,
   sleep,
 } from './coordinator/connection/utils';
+import { SFUResponse } from './gen/coordinator';
 import { Logger } from './coordinator/connection/types';
 import { getLogger } from './logger';
 
@@ -40,14 +42,9 @@ export type StreamSfuClientConstructor = {
   dispatcher: Dispatcher;
 
   /**
-   * The URL of the SFU to connect to.
+   * The SFU server to connect to.
    */
-  url: string;
-
-  /**
-   * The WebSocket endpoint of the SFU to connect to.
-   */
-  wsEndpoint: string;
+  sfuServer: SFUResponse;
 
   /**
    * The JWT token to use for authentication.
@@ -75,6 +72,21 @@ export class StreamSfuClient {
    */
   readonly sessionId: string;
 
+  /**
+   * The `edgeName` representing the edge the client is connected to.
+   */
+  readonly edgeName: string;
+
+  /**
+   * The current token used for authenticating against the SFU.
+   */
+  readonly token: string;
+
+  /**
+   * The SFU server details the current client is connected to.
+   */
+  readonly sfuServer: SFUResponse;
+
   /**
    * Holds the current WebSocket connection to the SFU.
    */
@@ -85,8 +97,13 @@ export class StreamSfuClient {
    */
   signalReady: Promise<WebSocket>;
 
+  /**
+   * A flag indicating whether the client is currently migrating away
+   * from this SFU.
+   */
+  isMigratingAway = false;
+
   private readonly rpc: SignalServerClient;
-  private readonly token: string;
   private keepAliveInterval?: NodeJS.Timeout;
   private connectionCheckTimeout?: NodeJS.Timeout;
   private pingIntervalInMs = 25 * 1000;
@@ -99,19 +116,19 @@ export class StreamSfuClient {
    * Constructs a new SFU client.
    *
    * @param dispatcher the event dispatcher to use.
-   * @param url the URL of the SFU.
-   * @param wsEndpoint the WebSocket endpoint of the SFU.
+   * @param sfuServer the SFU server to connect to.
    * @param token the JWT token to use for authentication.
    * @param sessionId the `sessionId` of the currently connected participant.
    */
   constructor({
     dispatcher,
-    url,
-    wsEndpoint,
+    sfuServer,
     token,
     sessionId,
   }: StreamSfuClientConstructor) {
     this.sessionId = sessionId || generateUUIDv4();
+    this.sfuServer = sfuServer;
+    this.edgeName = sfuServer.edge_name;
     this.token = token;
     this.logger = getLogger(['sfu-client']);
     const logger = this.logger;
@@ -122,13 +139,15 @@ export class StreamSfuClient {
         input: object,
         options: RpcOptions,
       ): UnaryCall {
-        logger('info', `Calling SFU RPC method ${method.name}`);
-        logger('debug', `Method call payload`, { input, options });
+        logger('trace', `Calling SFU RPC method ${method.name}`, {
+          input,
+          options,
+        });
         return next(method, input, options);
       },
     };
     this.rpc = createSignalClient({
-      baseUrl: url,
+      baseUrl: sfuServer.url,
       interceptors: [
         withHeaders({
           Authorization: `Bearer ${token}`,
@@ -149,7 +168,7 @@ export class StreamSfuClient {
     });
 
     this.signalWs = createWebSocketSignalChannel({
-      endpoint: wsEndpoint,
+      endpoint: sfuServer.ws_endpoint,
       onMessage: (message) => {
         this.lastMessageTimestamp = new Date();
         this.scheduleConnectionCheck();
@@ -158,10 +177,12 @@ export class StreamSfuClient {
     });
 
     this.signalReady = new Promise((resolve) => {
-      this.signalWs.addEventListener('open', () => {
+      const onOpen = () => {
+        this.signalWs.removeEventListener('open', onOpen);
         this.keepAlive();
         resolve(this.signalWs);
-      });
+      };
+      this.signalWs.addEventListener('open', onOpen);
     });
   }
 
@@ -262,6 +283,11 @@ export class StreamSfuClient {
 
   send = (message: SfuRequest) => {
     return this.signalReady.then((signal) => {
+      this.logger(
+        'debug',
+        `Sending message to: ${this.edgeName}`,
+        SfuRequest.toJson(message),
+      );
       signal.send(SfuRequest.toBinary(message));
     });
   };
@@ -271,7 +297,7 @@ export class StreamSfuClient {
       clearInterval(this.keepAliveInterval);
     }
     this.keepAliveInterval = setInterval(() => {
-      this.logger('info', 'Sending healthCheckRequest to SFU');
+      this.logger('trace', 'Sending healthCheckRequest to SFU');
       const message = SfuRequest.create({
         requestPayload: {
           oneofKind: 'healthCheckRequest',
@@ -326,6 +352,7 @@ const MAX_RETRIES = 5;
  * request bursts towards the SFU.
  *
  * @param rpc the closure around the RPC call to execute.
+ * @param logger a logger instance to use.
  * @param <I> the type of the request object.
  * @param <O> the type of the response object.
  */
@@ -343,10 +370,10 @@ const retryable = async <I extends object, O extends SfuResponseWithError>(
 
     rpcCallResult = await rpc();
     logger(
-      'info',
+      'trace',
       `SFU RPC response received for ${rpcCallResult.method.name}`,
+      rpcCallResult,
     );
-    logger('debug', `Response payload`, rpcCallResult);
 
     // if the RPC call failed, log the error and retry
     if (rpcCallResult.response.error) {

package/src/StreamVideoClient.ts

@@ -24,8 +24,8 @@ import type {
   ConnectionChangedEvent,
   EventHandler,
   EventTypes,
-  LogLevel,
   Logger,
+  LogLevel,
   StreamClientOptions,
   TokenOrProvider,
   TokenProvider,
@@ -44,7 +44,6 @@ export class StreamVideoClient {
   readonly readOnlyStateStore: StreamVideoReadOnlyStateStore;
   readonly user?: User;
   readonly token?: TokenOrProvider;
-  readonly logLevel: LogLevel = 'warn';
   readonly logger: Logger;
 
   private readonly writeableStateStore: StreamVideoWriteableStateStore;
@@ -53,7 +52,6 @@ export class StreamVideoClient {
   private eventHandlersToUnregister: Array<() => void> = [];
   private connectionPromise: Promise<void | ConnectedEvent> | undefined;
   private disconnectionPromise: Promise<void> | undefined;
-  private logLevels: LogLevel[] = ['debug', 'info', 'warn', 'error'];
 
   /**
    * You should create only one instance of `StreamVideoClient`.
@@ -79,29 +77,30 @@ export class StreamVideoClient {
     opts?: StreamClientOptions,
   ) {
     let logger: Logger = logToConsole;
+    let logLevel: LogLevel = 'warn';
     if (typeof apiKeyOrArgs === 'string') {
-      this.logLevel = opts?.logLevel || this.logLevel;
+      logLevel = opts?.logLevel || logLevel;
       logger = opts?.logger || logger;
     } else {
-      this.logLevel = apiKeyOrArgs.options?.logLevel || this.logLevel;
+      logLevel = apiKeyOrArgs.options?.logLevel || logLevel;
       logger = apiKeyOrArgs.options?.logger || logger;
     }
 
-    setLogger(this.filterLogs(logger));
+    setLogger(logger, logLevel);
     this.logger = getLogger(['client']);
 
     if (typeof apiKeyOrArgs === 'string') {
       this.streamClient = new StreamClient(apiKeyOrArgs, {
         persistUserOnConnectionFailure: true,
         ...opts,
-        logLevel: this.logLevel,
+        logLevel,
         logger: this.logger,
       });
     } else {
       this.streamClient = new StreamClient(apiKeyOrArgs.apiKey, {
         persistUserOnConnectionFailure: true,
         ...apiKeyOrArgs.options,
-        logLevel: this.logLevel,
+        logLevel,
         logger: this.logger,
       });
 
@@ -504,20 +503,4 @@ export class StreamVideoClient {
     this.connectionPromise.finally(() => (this.connectionPromise = undefined));
     return this.connectionPromise;
   };
-
-  private filterLogs = (logMethod: Logger) => {
-    return (
-      logLevel: LogLevel,
-      messeage: string,
-      extraData?: Record<string, unknown>,
-      tags?: string[],
-    ) => {
-      if (
-        this.logLevels.indexOf(logLevel) >=
-        this.logLevels.indexOf(this.logLevel)
-      ) {
-        logMethod(logLevel, messeage, extraData, tags);
-      }
-    };
-  };
 }

package/src/client-details.ts

@@ -1,4 +1,6 @@
-import { Device, OS, Sdk } from './gen/video/sfu/models/models';
+import { ClientDetails, Device, OS, Sdk } from './gen/video/sfu/models/models';
+import { isReactNative } from './helpers/platforms';
+import { UAParser } from 'ua-parser-js';
 
 let sdkInfo: Sdk | undefined;
 let osInfo: OS | undefined;
@@ -27,3 +29,33 @@ export const setDeviceInfo = (info: Device) => {
 export const getDeviceInfo = () => {
   return deviceInfo;
 };
+
+export const getClientDetails = (): ClientDetails => {
+  if (isReactNative()) {
+    // Since RN doesn't support web, sharing browser info is not required
+    return {
+      sdk: getSdkInfo(),
+      os: getOSInfo(),
+      device: getDeviceInfo(),
+    };
+  }
+
+  const userAgent = new UAParser(navigator.userAgent);
+  const { browser, os, device, cpu } = userAgent.getResult();
+  return {
+    sdk: getSdkInfo(),
+    browser: {
+      name: browser.name || navigator.userAgent,
+      version: browser.version || '',
+    },
+    os: {
+      name: os.name || '',
+      version: os.version || '',
+      architecture: cpu.architecture || '',
+    },
+    device: {
+      name: `${device.vendor || ''} ${device.model || ''} ${device.type || ''}`,
+      version: '',
+    },
+  };
+};

package/src/coordinator/connection/client.ts

@@ -134,8 +134,8 @@ export class StreamClient {
     }
 
     this.axiosInstance = axios.create({
-      baseURL: this.baseURL,
       ...this.options,
+      baseURL: this.baseURL,
     });
 
     // WS connection is initialized when setUser is called
@@ -457,7 +457,7 @@ export class StreamClient {
       this.listeners[key] = [];
     }
 
-    this.logger('info', `Removing listener for ${key} event`);
+    this.logger('debug', `Removing listener for ${key} event`);
     this.listeners[key] = this.listeners[key].filter(
       (value) => value !== callback,
     );
@@ -471,8 +471,7 @@ export class StreamClient {
       config?: AxiosRequestConfig & { maxBodyLength?: number };
     },
   ) {
-    this.logger('info', `client: ${type} - Request - ${url}`);
-    this.logger('debug', `client: ${type} - Request payload`, {
+    this.logger('trace', `client: ${type} - Request - ${url}`, {
       payload: data,
       config,
     });
@@ -480,13 +479,13 @@ export class StreamClient {
 
   _logApiResponse<T>(type: string, url: string, response: AxiosResponse<T>) {
     this.logger(
-      'info',
+      'trace',
       `client:${type} - Response - url: ${url} > status ${response.status}`,
       {
         response,
       },
     );
-    this.logger('debug', `client:${type} - Response payload`, {
+    this.logger('trace', `client:${type} - Response payload`, {
       response,
     });
   }
@@ -617,8 +616,7 @@ export class StreamClient {
   dispatchEvent = (event: StreamVideoEvent) => {
     if (!event.received_at) event.received_at = new Date();
 
-    this.logger('info', `Dispatching event: ${event.type}`);
-    this.logger('debug', 'Event payload:', event);
+    this.logger('debug', `Dispatching event: ${event.type}`, event);
     this._callClientListeners(event);
   };
 

package/src/coordinator/connection/types.ts

@@ -24,7 +24,7 @@ export type { OwnUserResponse } from '../../gen/coordinator';
 
 export type ConnectAPIResponse = Promise<void | ConnectedEvent>;
 
-export type LogLevel = 'debug' | 'info' | 'error' | 'warn';
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
 
 type ErrorResponseDetails = {
   code: number;
@@ -81,8 +81,7 @@ export type CallEventTypes = StreamCallEvent['type'];
 export type Logger = (
   logLevel: LogLevel,
   message: string,
-  extraData?: any,
-  tags?: string[],
+  ...args: unknown[]
 ) => void;
 
 export type StreamClientOptions = Partial<AxiosRequestConfig> & {

package/src/coordinator/connection/utils.ts

@@ -18,6 +18,7 @@ export function isFunction<T>(value: Function | T): value is Function {
 export const KnownCodes = {
   TOKEN_EXPIRED: 40,
   WS_CLOSED_SUCCESS: 1000,
+  WS_CLOSED_ABRUPTLY: 1006,
   WS_POLICY_VIOLATION: 1008,
 };
 

package/src/events/call.ts

@@ -1,7 +1,6 @@
 import { CallingState, CallState } from '../store';
 import { StreamVideoEvent } from '../coordinator/connection/types';
 import { Call } from '../Call';
-import { getLogger } from '../logger';
 
 /**
  * Event handler that watched the delivery of `call.accepted`.

package/src/events/callEventHandlers.ts

@@ -31,6 +31,7 @@ import {
   watchParticipantCountChanged,
   watchParticipantJoined,
   watchParticipantLeft,
+  watchSfuErrorReports,
   watchTrackPublished,
   watchTrackUnpublished,
   watchUnblockedUser,
@@ -92,6 +93,7 @@ export const registerEventHandlers = (
     'call.user_muted': () => console.log('call.user_muted received'),
   };
   const eventHandlers = [
+    watchSfuErrorReports(dispatcher),
     watchChangePublishQuality(dispatcher, call),
     watchConnectionQualityChanged(dispatcher, state),
     watchParticipantCountChanged(dispatcher, state),

package/src/events/internal.ts

@@ -2,6 +2,10 @@ import { Dispatcher } from '../rtc';
 import { Call } from '../Call';
 import { CallState } from '../store';
 import { StreamVideoParticipantPatches } from '../types';
+import { getLogger } from '../logger';
+import { ErrorCode } from '../gen/video/sfu/models/models';
+
+const logger = getLogger(['events']);
 
 /**
  * An event responder which handles the `changePublishQuality` event.
@@ -63,3 +67,19 @@ export const watchParticipantCountChanged = (
     }
   });
 };
+
+/**
+ * Watches and logs the errors reported by the currently connected SFU.
+ */
+export const watchSfuErrorReports = (dispatcher: Dispatcher) => {
+  return dispatcher.on('error', (e) => {
+    if (e.eventPayload.oneofKind !== 'error' || !e.eventPayload.error.error)
+      return;
+    const error = e.eventPayload.error.error;
+    logger('error', 'SFU reported error', {
+      code: ErrorCode[error.code],
+      message: error.message,
+      shouldRetry: error.shouldRetry,
+    });
+  });
+};

package/src/events/sessions.ts

@@ -1,6 +1,5 @@
 import { CallState } from '../store';
 import { StreamVideoEvent } from '../coordinator/connection/types';
-import { getLogger } from '../logger';
 
 /**
  * Watch for call.session_started events and update the call metadata.

package/src/gen/coordinator/index.ts

@@ -2457,6 +2457,12 @@ export interface JoinCallRequest {
    * @memberof JoinCallRequest
    */
   members_limit?: number;
+  /**
+   * If the participant is migrating from another SFU, then this is the ID of the previous SFU
+   * @type {string}
+   * @memberof JoinCallRequest
+   */
+  migrating_from?: string;
   /**
    *
    * @type {boolean}