@stream-io/video-client 1.53.2 → 1.54.1-beta.0

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/Publisher.ts

@@ -39,6 +39,7 @@ export class Publisher extends BasePeerConnection {
   private readonly transceiverCache = new TransceiverCache();
   private readonly clonedTracks = new Set<MediaStreamTrack>();
   private publishOptions: PublishOption[];
+  private readonly selfSubEnabled: boolean;
 
   /**
    * Constructs a new `Publisher` instance.
@@ -46,9 +47,11 @@ export class Publisher extends BasePeerConnection {
   constructor(
     baseOptions: BasePeerConnectionOpts,
     publishOptions: PublishOption[],
+    opts: { selfSubEnabled?: boolean } = {},
   ) {
     super(PeerType.PUBLISHER_UNSPECIFIED, baseOptions);
     this.publishOptions = publishOptions;
+    this.selfSubEnabled = opts.selfSubEnabled ?? false;
 
     this.on('iceRestart', (iceRestart) => {
       if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED) return;
@@ -576,6 +579,7 @@ export class Publisher extends BasePeerConnection {
       muted: !isTrackLive,
       codec: publishOption.codec,
       publishOptionId: publishOption.id,
+      selfSubAudioVideo: this.selfSubEnabled,
     };
   };
 

package/src/rtc/Subscriber.ts

@@ -14,6 +14,14 @@ import { enableStereo, removeCodecsExcept } from './helpers/sdp';
  * @internal
  */
 export class Subscriber extends BasePeerConnection {
+  /**
+   * Remote streams received from the SFU. For a self-sub case
+   * we need to be able to distinguish between the local capture stream.
+   * The map will never contain local streams so we can safely use it to
+   * check if the stream is remote and dispose it when needed.
+   */
+  private trackedStreams: WeakSet<MediaStream> = new WeakSet();
+
   /**
    * Constructs a new `Subscriber` instance.
    */
@@ -75,6 +83,7 @@ export class Subscriber extends BasePeerConnection {
     const participantToUpdate = this.state.participants.find(
       (p) => p.trackLookupPrefix === trackId,
     );
+    const isSelfSub = !!participantToUpdate?.isLocalParticipant;
     this.logger.debug(
       `[onTrack]: Got remote ${rawTrackType} track for userId: ${participantToUpdate?.userId}`,
       track.id,
@@ -108,6 +117,10 @@ export class Subscriber extends BasePeerConnection {
 
     this.trackIdToTrackType.set(track.id, trackType);
 
+    if (isSelfSub) {
+      this.trackedStreams.add(primaryStream);
+    }
+
     if (!participantToUpdate) {
       this.logger.warn(
         `[onTrack]: Received track for unknown participant: ${trackId}`,
@@ -128,6 +141,13 @@ export class Subscriber extends BasePeerConnection {
       return;
     }
 
+    // Self-sub loopback audio routes to the speaker by default, which
+    // would echo the local user's voice. Default-mute here; consumers
+    // (the loopback recording hook) re-enable explicitly when needed.
+    if (isSelfSub && e.track.kind === 'audio') {
+      e.track.enabled = false;
+    }
+
     // get the previous stream to dispose it later
     // usually this happens during migration, when the stream is replaced
     // with a new one but the old one is still in the state
@@ -138,8 +158,15 @@ export class Subscriber extends BasePeerConnection {
       [streamKindProp]: primaryStream,
     });
 
-    // now, dispose the previous stream if it exists
     if (previousStream) {
+      if (isSelfSub && !this.trackedStreams.has(previousStream)) {
+        // this is the local capture stream, we don't want to dispose it
+        this.logger.debug(
+          `[onTrack]: Skipping cleanup of previous ${e.track.kind} stream for userId: ${participantToUpdate.userId} because it is not tracked`,
+        );
+        return;
+      }
+
       this.logger.info(
         `[onTrack]: Cleaning up previous remote ${track.kind} tracks for userId: ${participantToUpdate.userId}`,
       );

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.