@stream-io/video-client 1.53.1 → 1.54.0

package/dist/src/coordinator/connection/types.d.ts

@@ -148,6 +148,12 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
      */
     baseURL?: string;
     browser?: boolean;
+    /**
+     * Enables the client-side event reporter (call lifecycle telemetry).
+     * Set to `false` for non-interactive sessions such as egress/recording
+     * where the telemetry adds no value. Defaults to `true`.
+     */
+    clientEventsReportingEnabled?: boolean;
     /**
      *  @deprecated Use `logOptions` instead.
      *  Custom logger instance used to handle log messages.

package/dist/src/reporting/ClientEventReporter.d.ts

@@ -15,10 +15,12 @@ export type CallReportContext = {
 };
 export type ClientEventReporterOptions = {
     streamClient: StreamClient;
+    enabled?: boolean;
 };
 export declare class ClientEventReporter {
     private readonly logger;
     private streamClient;
+    private enabled;
     private coordinatorConnectId?;
     private coordinatorConnectUserId?;
     private coordinatorWsPair?;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.53.1",
+  "version": "1.54.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/Call.ts

@@ -1230,7 +1230,10 @@ export class Call {
       const isReconnecting =
         this.reconnectStrategy !== WebsocketReconnectStrategy.UNSPECIFIED;
       const reconnectDetails = isReconnecting
-        ? this.getReconnectDetails(data?.migrating_from, previousSessionId)
+        ? this.getReconnectDetails(
+            previousSfuClient?.edgeName,
+            previousSessionId,
+          )
         : undefined;
       const preferredPublishOptions = !isReconnecting
         ? this.getPreferredPublishOptions()
@@ -1692,6 +1695,7 @@ export class Call {
       const reconnectStartTime = Date.now();
       this.reconnectStrategy = strategy;
       this.reconnectReason = reason;
+      const sfuRejoinFailures = new Map<string, number>();
 
       const markAsReconnectingFailed = async () => {
         try {
@@ -1764,8 +1768,8 @@ export class Call {
         if (this.reconnectStrategy !== WebsocketReconnectStrategy.FAST) {
           this.reconnectAttempts++;
         }
-        const currentStrategy =
-          WebsocketReconnectStrategy[this.reconnectStrategy];
+        const attemptedStrategy = this.reconnectStrategy;
+        const currentStrategy = WebsocketReconnectStrategy[attemptedStrategy];
         try {
           // wait until the network is available
           await this.networkAvailableTask?.promise;
@@ -1786,9 +1790,25 @@ export class Call {
             case WebsocketReconnectStrategy.FAST:
               await this.reconnectFast();
               break;
-            case WebsocketReconnectStrategy.REJOIN:
-              await this.reconnectRejoin();
+            case WebsocketReconnectStrategy.REJOIN: {
+              const confirmedBadSfus = Array.from(sfuRejoinFailures)
+                .filter(([, failures]) => failures >= 2)
+                .map(([sfu]) => sfu);
+
+              if (this.joinCallData && confirmedBadSfus.length) {
+                this.joinCallData.migrating_from =
+                  confirmedBadSfus[confirmedBadSfus.length - 1];
+                this.joinCallData.migrating_from_list = confirmedBadSfus;
+              }
+
+              try {
+                await this.reconnectRejoin();
+              } finally {
+                delete this.joinCallData?.migrating_from;
+                delete this.joinCallData?.migrating_from_list;
+              }
               break;
+            }
             case WebsocketReconnectStrategy.MIGRATE:
               await this.reconnectMigrate();
               break;
@@ -1803,6 +1823,20 @@ export class Call {
           this.consecutiveNegotiationFailures = 0;
           break; // do-while loop, reconnection worked, exit the loop
         } catch (error) {
+          if (attemptedStrategy === WebsocketReconnectStrategy.REJOIN) {
+            const failedSfu = this.credentials?.server.edge_name;
+            if (failedSfu) {
+              const switchSfu =
+                error instanceof SfuJoinError &&
+                SfuJoinError.isJoinErrorCode(error.errorEvent);
+              const failures = (sfuRejoinFailures.get(failedSfu) ?? 0) + 1;
+              sfuRejoinFailures.set(
+                failedSfu,
+                switchSfu ? Math.max(failures, 2) : failures,
+              );
+            }
+          }
+
           if (this.state.callingState === CallingState.OFFLINE) {
             this.logger.debug(
               `[Reconnect] Can't reconnect while offline, stopping reconnection attempts`,
@@ -2057,6 +2091,7 @@ export class Call {
           this.sfuStatsReporter?.stop();
           this.state.setCallingState(CallingState.OFFLINE);
         } else {
+          if (!this.networkAvailableTask) return;
           this.logger.debug('[Reconnect] Going online');
           this.sfuClient?.close(
             StreamSfuClient.DISPOSE_OLD_SOCKET,

package/src/StreamVideoClient.ts

@@ -101,6 +101,7 @@ export class StreamVideoClient {
     this.streamClient = createCoordinatorClient(apiKey, clientOptions);
     this.clientEventReporter = new ClientEventReporter({
       streamClient: this.streamClient,
+      enabled: clientOptions?.clientEventsReportingEnabled ?? true,
     });
 
     this.writeableStateStore = new StreamVideoWriteableStateStore();

package/src/coordinator/connection/types.ts

@@ -213,6 +213,13 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
   baseURL?: string;
   browser?: boolean;
 
+  /**
+   * Enables the client-side event reporter (call lifecycle telemetry).
+   * Set to `false` for non-interactive sessions such as egress/recording
+   * where the telemetry adds no value. Defaults to `true`.
+   */
+  clientEventsReportingEnabled?: boolean;
+
   /**
    *  @deprecated Use `logOptions` instead.
    *  Custom logger instance used to handle log messages.

package/src/reporting/ClientEventReporter.ts

@@ -64,6 +64,7 @@ export type CallReportContext = {
 
 export type ClientEventReporterOptions = {
   streamClient: StreamClient;
+  enabled?: boolean;
 };
 
 type StageError = {
@@ -94,6 +95,7 @@ export class ClientEventReporter {
   private readonly logger = videoLoggerSystem.getLogger('ClientEventReporter');
 
   private streamClient: StreamClient;
+  private enabled: boolean;
 
   private coordinatorConnectId?: string;
   private coordinatorConnectUserId?: string;
@@ -112,6 +114,7 @@ export class ClientEventReporter {
 
   constructor(options: ClientEventReporterOptions) {
     this.streamClient = options.streamClient;
+    this.enabled = options.enabled ?? true;
   }
 
   /**
@@ -393,7 +396,7 @@ export class ClientEventReporter {
     const ctx = this.callContexts.get(cid);
 
     this.send({
-      user_id: this.streamClient.userID,
+      user_id: this.streamClient.userID || this.coordinatorConnectUserId,
       type: ctx?.callType,
       id: ctx?.callId,
       call_cid: cid,
@@ -712,7 +715,7 @@ export class ClientEventReporter {
     const ctx = this.callContexts.get(cid);
     const coordinatorConnectId = this.coordinatorConnectId;
     return {
-      user_id: this.streamClient.userID,
+      user_id: this.streamClient.userID || this.coordinatorConnectUserId,
       type: ctx?.callType ?? '',
       id: ctx?.callId ?? '',
       call_cid: cid,
@@ -731,6 +734,7 @@ export class ClientEventReporter {
   };
 
   private send = (body: Record<string, unknown>) => {
+    if (!this.enabled) return;
     void this.sendWithRetry(body);
   };
 

package/src/reporting/__tests__/ClientEventReporter.test.ts

@@ -618,3 +618,36 @@ describe('ClientEventReporter', () => {
     expect(ws2.every((e) => e.sfu_id === 'sfu-2')).toBe(true);
   });
 });
+
+describe('ClientEventReporter (disabled)', () => {
+  const cid = 'default:call-1';
+  let doAxiosRequest: ReturnType<typeof vi.fn>;
+  let reporter: ClientEventReporter;
+
+  beforeEach(() => {
+    doAxiosRequest = vi.fn().mockResolvedValue({});
+    const streamClient = fromPartial<StreamClient>({
+      userID: 'user-1',
+      doAxiosRequest,
+      getUserAgent: () => 'test-agent',
+      getSdkVersion: () => '1.0.0',
+    });
+    reporter = new ClientEventReporter({ streamClient, enabled: false });
+    reporter.startCoordinatorConnection('user-1');
+    reporter.registerCall(cid, {
+      callType: 'default',
+      callId: 'call-1',
+      getCallSessionId: () => 'session-1',
+      getSfuId: () => 'sfu-1',
+      getUserSessionId: () => 'user-session-1',
+    });
+  });
+
+  it('does not post any events when disabled', async () => {
+    reporter.startCorrelation(cid, 'first-attempt');
+    await reporter.track(cid, 'CoordinatorJoin', () => Promise.resolve('ok'));
+    await flush();
+
+    expect(doAxiosRequest).not.toHaveBeenCalled();
+  });
+});

package/src/rtc/__tests__/Call.reconnect.test.ts

@@ -19,19 +19,23 @@ import { Subscriber } from '../Subscriber';
 import { Dispatcher } from '../Dispatcher';
 import { StreamSfuClient } from '../../StreamSfuClient';
 import { IceTrickleBuffer } from '../IceTrickleBuffer';
+import { SfuJoinError } from '../../errors';
 
 vi.mock('../../StreamSfuClient', () => ({
   StreamSfuClient: vi.fn(),
 }));
 
-const makeCall = () => {
+const makeCall = ({ reportingEnabled = false } = {}) => {
   const streamClient = new StreamClient('test-key');
   const clientStore = new StreamVideoWriteableStateStore();
   return new Call({
     type: 'default',
     id: 'test-call',
     streamClient,
-    clientEventReporter: new ClientEventReporter({ streamClient }),
+    clientEventReporter: new ClientEventReporter({
+      streamClient,
+      enabled: reportingEnabled,
+    }),
     clientStore,
     ringing: false,
     watching: false,
@@ -406,6 +410,149 @@ describe('Call reconnect stopping conditions', () => {
   });
 });
 
+describe('Call reconnect rejoin SFU migration hints', () => {
+  let call: Call;
+  const credentials = {
+    server: {
+      url: 'https://getstream.io/',
+      ws_endpoint: 'https://getstream.io/ws',
+      edge_name: 'sfu-1',
+    },
+    token: 'token',
+    ice_servers: [],
+  };
+
+  beforeEach(() => {
+    call = makeCall();
+    call['credentials'] = credentials;
+    call['joinCallData'] = { create: true };
+    primeForReconnect(call);
+    call.setRejoinAttemptLimit(3, 60);
+    vi.spyOn(connectionUtils, 'sleep').mockResolvedValue(undefined);
+    vi.spyOn(call, 'leave').mockResolvedValue(undefined);
+    vi.spyOn(call, 'get').mockResolvedValue({} as never);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('asks the coordinator to avoid an SFU after repeated rejoin failures without leaking migration hints', async () => {
+    const doJoinRequestArgs: unknown[] = [];
+    const doJoinRequest = vi
+      .spyOn(
+        call as unknown as {
+          doJoinRequest: (data?: unknown) => Promise<unknown>;
+        },
+        'doJoinRequest',
+      )
+      .mockImplementation(async (data?: unknown) => {
+        doJoinRequestArgs.push(JSON.parse(JSON.stringify(data)));
+        throw new Error('rejoin failed');
+      });
+
+    await call['reconnect'](WebsocketReconnectStrategy.REJOIN, 'test');
+
+    expect(doJoinRequest).toHaveBeenCalledTimes(3);
+    expect(doJoinRequestArgs[0]).toEqual({ create: true });
+    expect(doJoinRequestArgs[1]).toEqual({ create: true });
+    expect(doJoinRequestArgs[2]).toEqual({
+      create: true,
+      migrating_from: 'sfu-1',
+      migrating_from_list: ['sfu-1'],
+    });
+    expect(call['joinCallData']).toEqual({ create: true });
+  });
+
+  it('asks the coordinator to avoid an SFU immediately after an SFU join error', async () => {
+    call.setRejoinAttemptLimit(2, 60);
+    const doJoinRequestArgs: unknown[] = [];
+    const sfuFullError = new SfuJoinError({
+      error: {
+        code: ErrorCode.SFU_FULL,
+        message: 'SFU is full',
+      },
+      reconnectStrategy: WebsocketReconnectStrategy.REJOIN,
+    } as never);
+    const doJoinRequest = vi
+      .spyOn(
+        call as unknown as {
+          doJoinRequest: (data?: unknown) => Promise<unknown>;
+        },
+        'doJoinRequest',
+      )
+      .mockImplementationOnce(async (data?: unknown) => {
+        doJoinRequestArgs.push(JSON.parse(JSON.stringify(data)));
+        throw sfuFullError;
+      })
+      .mockImplementation(async (data?: unknown) => {
+        doJoinRequestArgs.push(JSON.parse(JSON.stringify(data)));
+        throw new Error('rejoin failed');
+      });
+
+    await call['reconnect'](WebsocketReconnectStrategy.REJOIN, 'test');
+
+    expect(doJoinRequest).toHaveBeenCalledTimes(2);
+    expect(doJoinRequestArgs[0]).toEqual({ create: true });
+    expect(doJoinRequestArgs[1]).toEqual({
+      create: true,
+      migrating_from: 'sfu-1',
+      migrating_from_list: ['sfu-1'],
+    });
+    expect(call['joinCallData']).toEqual({ create: true });
+  });
+
+  it('gives every SFU two tries before excluding it (a once-failed SFU is re-served, not yet listed)', async () => {
+    call.setRejoinAttemptLimit(5, 60);
+    call['credentials'] = {
+      ...credentials,
+      server: { ...credentials.server, edge_name: 'sfu-a' },
+    };
+
+    const pool = ['sfu-a', 'sfu-b', 'sfu-c'];
+    const sent: Array<{
+      migrating_from?: string;
+      migrating_from_list?: string[];
+    }> = [];
+    vi.spyOn(
+      call as unknown as {
+        doJoinRequest: (data?: unknown) => Promise<unknown>;
+      },
+      'doJoinRequest',
+    ).mockImplementation(async (data?: unknown) => {
+      const clone = JSON.parse(JSON.stringify(data ?? {}));
+      sent.push(clone);
+      const excluded = new Set<string>(clone.migrating_from_list ?? []);
+      const assigned = pool.find((s) => !excluded.has(s)) ?? pool.at(-1)!;
+      call['credentials'] = {
+        ...credentials,
+        server: { ...credentials.server, edge_name: assigned },
+      };
+      throw new Error('connect failed');
+    });
+
+    await call['reconnect'](WebsocketReconnectStrategy.REJOIN, 'test');
+
+    expect(sent).toHaveLength(5);
+    expect(sent[0].migrating_from_list).toBeUndefined();
+    expect(sent[1].migrating_from_list).toBeUndefined();
+    expect(sent[2].migrating_from).toBe('sfu-a');
+    expect(sent[2].migrating_from_list).toEqual(['sfu-a']);
+    expect(sent[3].migrating_from).toBe('sfu-a');
+    expect(sent[3].migrating_from_list).toEqual(['sfu-a']);
+    expect(sent[3].migrating_from_list).not.toContain('sfu-b');
+    expect(sent[4].migrating_from).toBe('sfu-b');
+    expect(sent[4].migrating_from_list).toEqual(['sfu-a', 'sfu-b']);
+
+    for (const req of sent) {
+      if (req.migrating_from) {
+        expect(req.migrating_from_list).toContain(req.migrating_from);
+      }
+    }
+    expect(call['joinCallData']).toEqual({ create: true });
+  });
+});
+
 /**
  * Entry-condition bails. `reconnect()` must drop new triggers when:
  * - A join/reconnect/migrate lifecycle is already in progress.