@stream-io/video-client 0.0.28 → 0.0.29

package/src/rtc/Subscriber.ts

@@ -0,0 +1,304 @@
+import { StreamSfuClient } from '../StreamSfuClient';
+import { getIceCandidate } from './helpers/iceCandidate';
+import { PeerType } from '../gen/video/sfu/models/models';
+import { SubscriberOffer } from '../gen/video/sfu/event/events';
+import { Dispatcher } from './Dispatcher';
+import { getLogger } from '../logger';
+import { CallState } from '../store';
+
+export type SubscriberOpts = {
+  sfuClient: StreamSfuClient;
+  dispatcher: Dispatcher;
+  state: CallState;
+  connectionConfig?: RTCConfiguration;
+};
+
+const logger = getLogger(['Subscriber']);
+
+/**
+ * A wrapper around the `RTCPeerConnection` that handles the incoming
+ * media streams from the SFU.
+ */
+export class Subscriber {
+  private pc: RTCPeerConnection;
+  private readonly unregisterOnSubscriberOffer: () => void;
+  private sfuClient: StreamSfuClient;
+  private dispatcher: Dispatcher;
+  private state: CallState;
+
+  /**
+   * Constructs a new `Subscriber` instance.
+   *
+   * @param sfuClient the SFU client to use.
+   * @param dispatcher the dispatcher to use.
+   * @param state the state of the call.
+   * @param connectionConfig the connection configuration to use.
+   */
+  constructor({
+    sfuClient,
+    dispatcher,
+    state,
+    connectionConfig,
+  }: SubscriberOpts) {
+    this.sfuClient = sfuClient;
+    this.dispatcher = dispatcher;
+    this.state = state;
+
+    this.pc = this.createPeerConnection(connectionConfig);
+
+    this.unregisterOnSubscriberOffer = dispatcher.on(
+      'subscriberOffer',
+      async (message) => {
+        if (message.eventPayload.oneofKind !== 'subscriberOffer') return;
+        const { subscriberOffer } = message.eventPayload;
+        await this.negotiate(subscriberOffer);
+      },
+    );
+  }
+
+  /**
+   * Creates a new `RTCPeerConnection` instance with the given configuration.
+   *
+   * @param connectionConfig the connection configuration to use.
+   */
+  private createPeerConnection = (connectionConfig?: RTCConfiguration) => {
+    const pc = new RTCPeerConnection(connectionConfig);
+    pc.addEventListener('icecandidate', this.onIceCandidate);
+    pc.addEventListener('track', this.handleOnTrack);
+
+    pc.addEventListener('icecandidateerror', this.onIceCandidateError);
+    pc.addEventListener(
+      'iceconnectionstatechange',
+      this.onIceConnectionStateChange,
+    );
+    pc.addEventListener(
+      'icegatheringstatechange',
+      this.onIceGatheringStateChange,
+    );
+
+    return pc;
+  };
+
+  /**
+   * Closes the `RTCPeerConnection` and unsubscribes from the dispatcher.
+   */
+  close = () => {
+    this.unregisterOnSubscriberOffer();
+    this.pc.close();
+  };
+
+  /**
+   * Returns the result of the `RTCPeerConnection.getStats()` method
+   * @param selector
+   * @returns
+   */
+  getStats = (selector?: MediaStreamTrack | null | undefined) => {
+    return this.pc.getStats(selector);
+  };
+
+  /**
+   * Migrates the subscriber to a new SFU client.
+   *
+   * @param sfuClient the new SFU client to migrate to.
+   * @param connectionConfig the new connection configuration to use.
+   */
+  migrateTo = (
+    sfuClient: StreamSfuClient,
+    connectionConfig?: RTCConfiguration,
+  ) => {
+    this.sfuClient = sfuClient;
+
+    // when migrating, we want to keep the previous subscriber open
+    // until the new one is connected
+    const previousPC = this.pc;
+
+    // we keep a record of previously available video tracks
+    // so that we can monitor when they become available on the new
+    // subscriber and close the previous one.
+    const trackIdsToMigrate = new Set<string>();
+    previousPC.getReceivers().forEach((r) => {
+      if (r.track.kind === 'video') {
+        trackIdsToMigrate.add(r.track.id);
+      }
+    });
+
+    // set up a new subscriber peer connection, configured to connect
+    // to the new SFU node
+    const pc = this.createPeerConnection(connectionConfig);
+
+    let migrationTimeoutId: NodeJS.Timeout;
+    const cleanupMigration = () => {
+      previousPC.close();
+      clearTimeout(migrationTimeoutId);
+    };
+
+    // When migrating, we want to keep track of the video tracks
+    // that are migrating to the new subscriber.
+    // Once all of them are available, we can close the previous subscriber.
+    const handleTrackMigration = (e: RTCTrackEvent) => {
+      logger(
+        'debug',
+        `[Migration]: Migrated track: ${e.track.id}, ${e.track.kind}`,
+      );
+      trackIdsToMigrate.delete(e.track.id);
+      if (trackIdsToMigrate.size === 0) {
+        logger('debug', `[Migration]: Migration complete`);
+        pc.removeEventListener('track', handleTrackMigration);
+        cleanupMigration();
+      }
+    };
+
+    // When migrating, we want to keep track of the connection state
+    // of the new subscriber.
+    // Once it is connected, we give it a 2-second grace period to receive
+    // all the video tracks that are migrating from the previous subscriber.
+    // After this threshold, we abruptly close the previous subscriber.
+    const handleConnectionStateChange = () => {
+      if (pc.connectionState === 'connected') {
+        migrationTimeoutId = setTimeout(() => {
+          pc.removeEventListener('track', handleTrackMigration);
+          cleanupMigration();
+        }, 2000);
+
+        pc.removeEventListener(
+          'connectionstatechange',
+          handleConnectionStateChange,
+        );
+      }
+    };
+
+    pc.addEventListener('track', handleTrackMigration);
+    pc.addEventListener('connectionstatechange', handleConnectionStateChange);
+
+    // replace the PeerConnection instance
+    this.pc = pc;
+  };
+
+  private handleOnTrack = (e: RTCTrackEvent) => {
+    const [primaryStream] = e.streams;
+    // example: `e3f6aaf8-b03d-4911-be36-83f47d37a76a:TRACK_TYPE_VIDEO`
+    const [trackId, trackType] = primaryStream.id.split(':');
+    const participantToUpdate = this.state.participants.find(
+      (p) => p.trackLookupPrefix === trackId,
+    );
+    logger(
+      'debug',
+      `[onTrack]: Got remote ${trackType} track for userId: ${participantToUpdate?.userId}`,
+      e.track.id,
+      e.track,
+    );
+    if (!participantToUpdate) {
+      logger(
+        'error',
+        `[onTrack]: Received track for unknown participant: ${trackId}`,
+        e,
+      );
+      return;
+    }
+
+    e.track.addEventListener('mute', () => {
+      logger(
+        'info',
+        `[onTrack]: Track muted: ${participantToUpdate.userId} ${trackType}:${trackId}`,
+      );
+    });
+
+    e.track.addEventListener('unmute', () => {
+      logger(
+        'info',
+        `[onTrack]: Track unmuted: ${participantToUpdate.userId} ${trackType}:${trackId}`,
+      );
+    });
+
+    e.track.addEventListener('ended', () => {
+      logger(
+        'info',
+        `[onTrack]: Track ended: ${participantToUpdate.userId} ${trackType}:${trackId}`,
+      );
+    });
+
+    const streamKindProp = (
+      {
+        TRACK_TYPE_AUDIO: 'audioStream',
+        TRACK_TYPE_VIDEO: 'videoStream',
+        TRACK_TYPE_SCREEN_SHARE: 'screenShareStream',
+      } as const
+    )[trackType];
+
+    if (!streamKindProp) {
+      logger('error', `Unknown track type: ${trackType}`);
+      return;
+    }
+    const previousStream = participantToUpdate[streamKindProp];
+    if (previousStream) {
+      logger(
+        'info',
+        `[onTrack]: Cleaning up previous remote ${e.track.kind} tracks for userId: ${participantToUpdate.userId}`,
+      );
+      previousStream.getTracks().forEach((t) => {
+        t.stop();
+        previousStream.removeTrack(t);
+      });
+    }
+    this.state.updateParticipant(participantToUpdate.sessionId, {
+      [streamKindProp]: primaryStream,
+    });
+  };
+
+  private onIceCandidate = async (e: RTCPeerConnectionIceEvent) => {
+    const { candidate } = e;
+    if (!candidate) {
+      logger('warn', 'null ice candidate');
+      return;
+    }
+
+    await this.sfuClient.iceTrickle({
+      iceCandidate: getIceCandidate(candidate),
+      peerType: PeerType.SUBSCRIBER,
+    });
+  };
+
+  private negotiate = async (subscriberOffer: SubscriberOffer) => {
+    logger('info', `Received subscriberOffer`, subscriberOffer);
+
+    await this.pc.setRemoteDescription({
+      type: 'offer',
+      sdp: subscriberOffer.sdp,
+    });
+
+    this.sfuClient.iceTrickleBuffer.subscriberCandidates.subscribe(
+      async (candidate) => {
+        try {
+          const iceCandidate = JSON.parse(candidate.iceCandidate);
+          await this.pc.addIceCandidate(iceCandidate);
+        } catch (e) {
+          logger('error', `ICE candidate error`, [e, candidate]);
+        }
+      },
+    );
+
+    // apply ice candidates
+    const answer = await this.pc.createAnswer();
+    await this.pc.setLocalDescription(answer);
+
+    await this.sfuClient.sendAnswer({
+      peerType: PeerType.SUBSCRIBER,
+      sdp: answer.sdp || '',
+    });
+  };
+
+  private onIceConnectionStateChange = () => {
+    logger('info', `ICE connection state changed`, this.pc.iceConnectionState);
+  };
+
+  private onIceGatheringStateChange = () => {
+    logger('info', `ICE gathering state changed`, this.pc.iceGatheringState);
+  };
+
+  private onIceCandidateError = (e: Event) => {
+    const errorMessage =
+      e instanceof RTCPeerConnectionIceErrorEvent &&
+      `${e.errorCode}: ${e.errorText}`;
+    logger('error', `ICE Candidate error`, errorMessage);
+  };
+}

package/src/rtc/__tests__/{publisher.test.ts → Publisher.test.ts}

@@ -1,11 +1,12 @@
 import './mocks/webrtc.mocks';
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { Publisher } from '../publisher';
+import { Publisher } from '../Publisher';
 import { CallState } from '../../store';
 import { StreamSfuClient } from '../../StreamSfuClient';
 import { Dispatcher } from '../Dispatcher';
 import { TrackType } from '../../gen/video/sfu/models/models';
+import { IceTrickleBuffer } from '../IceTrickleBuffer';
 
 vi.mock('../../StreamSfuClient', () => {
   console.log('MOCKING StreamSfuClient');
@@ -37,8 +38,11 @@ describe('Publisher', () => {
     const dispatcher = new Dispatcher();
     sfuClient = new StreamSfuClient({
       dispatcher,
-      url: 'https://getstream.io/',
-      wsEndpoint: 'https://getstream.io/ws',
+      sfuServer: {
+        url: 'https://getstream.io/',
+        ws_endpoint: 'https://getstream.io/ws',
+        edge_name: 'sfu-1',
+      },
       token: 'token',
     });
 
@@ -82,12 +86,8 @@ describe('Publisher', () => {
 
     const transceiver = new RTCRtpTransceiver();
     vi.spyOn(transceiver.sender, 'track', 'get').mockReturnValue(track);
-    vi.spyOn(publisher['publisher'], 'addTransceiver').mockReturnValue(
-      transceiver,
-    );
-    vi.spyOn(publisher['publisher'], 'getTransceivers').mockReturnValue([
-      transceiver,
-    ]);
+    vi.spyOn(publisher['pc'], 'addTransceiver').mockReturnValue(transceiver);
+    vi.spyOn(publisher['pc'], 'getTransceivers').mockReturnValue([transceiver]);
 
     sfuClient.updateMuteState = vi.fn();
 
@@ -141,4 +141,72 @@ describe('Publisher', () => {
     );
     expect(state.localParticipant?.videoDeviceId).toEqual('test-device-id-2');
   });
+
+  describe('Publisher migration', () => {
+    it('should update the sfuClient and peer connection configuration', async () => {
+      const newSfuClient = new StreamSfuClient({
+        dispatcher: new Dispatcher(),
+        sfuServer: {
+          url: 'https://getstream.io/',
+          ws_endpoint: 'https://getstream.io/ws',
+          edge_name: 'sfu-1',
+        },
+        token: 'token',
+      });
+
+      const newPeerConnectionConfig = {
+        iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+      };
+
+      vi.spyOn(publisher['pc'], 'setConfiguration');
+      // @ts-ignore
+      publisher['pc'].iceConnectionState = 'connected';
+      // @ts-ignore
+      vi.spyOn(publisher, 'negotiate').mockReturnValue(Promise.resolve());
+      vi.spyOn(publisher, 'isPublishing').mockReturnValue(true);
+
+      await publisher.migrateTo(newSfuClient, newPeerConnectionConfig);
+
+      expect(publisher['sfuClient']).toEqual(newSfuClient);
+      expect(publisher['pc'].setConfiguration).toHaveBeenCalledWith(
+        newPeerConnectionConfig,
+      );
+      expect(publisher['negotiate']).toHaveBeenCalledWith({ iceRestart: true });
+    });
+
+    it('should initiate ICE Restart when there are published tracks', async () => {
+      vi.spyOn(publisher['pc'], 'getTransceivers').mockReturnValue([]);
+      // @ts-ignore
+      sfuClient['iceTrickleBuffer'] = new IceTrickleBuffer();
+      sfuClient.setPublisher = vi.fn().mockResolvedValue({
+        response: {
+          sessionId: 'new-session-id',
+          sdp: 'new-sdp',
+          iceRestart: false,
+        },
+      });
+
+      // @ts-ignore
+      publisher['pc'].iceConnectionState = 'connected';
+      vi.spyOn(publisher, 'isPublishing').mockReturnValue(true);
+      vi.spyOn(publisher, 'getCurrentTrackInfos').mockReturnValue([
+        // @ts-expect-error
+        { layers: [], trackType: TrackType.AUDIO, mid: '0' },
+      ]);
+
+      await publisher.migrateTo(sfuClient, {
+        iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+      });
+
+      expect(publisher['pc'].createOffer).toHaveBeenCalledWith({
+        iceRestart: true,
+      });
+      expect(publisher['pc'].setLocalDescription).toHaveBeenCalled();
+      expect(publisher['pc'].setRemoteDescription).toHaveBeenCalledWith({
+        type: 'answer',
+        sdp: 'new-sdp',
+      });
+      expect(sfuClient.setPublisher).toHaveBeenCalled();
+    });
+  });
 });

package/src/rtc/__tests__/Subscriber.test.ts

@@ -0,0 +1,121 @@
+import './mocks/webrtc.mocks';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Dispatcher } from '../Dispatcher';
+import { StreamSfuClient } from '../../StreamSfuClient';
+import { Subscriber } from '../Subscriber';
+import { CallState } from '../../store';
+
+vi.mock('../../StreamSfuClient', () => {
+  console.log('MOCKING StreamSfuClient');
+  return {
+    StreamSfuClient: vi.fn(),
+  };
+});
+
+describe('Subscriber', () => {
+  let sfuClient: StreamSfuClient;
+  let subscriber: Subscriber;
+  let state = new CallState();
+
+  beforeEach(() => {
+    const dispatcher = new Dispatcher();
+    sfuClient = new StreamSfuClient({
+      dispatcher,
+      sfuServer: {
+        url: 'https://getstream.io/',
+        ws_endpoint: 'https://getstream.io/ws',
+        edge_name: 'sfu-1',
+      },
+      token: 'token',
+    });
+
+    subscriber = new Subscriber({
+      sfuClient,
+      dispatcher,
+      state,
+      connectionConfig: { iceServers: [] },
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  describe('Subscriber migration', () => {
+    it('should update the sfuClient and create a new peer connection', async () => {
+      const newSfuClient = new StreamSfuClient({
+        dispatcher: new Dispatcher(),
+        sfuServer: {
+          url: 'https://getstream.io/',
+          ws_endpoint: 'https://getstream.io/ws',
+          edge_name: 'sfu-1',
+        },
+        token: 'token',
+      });
+      const newConnectionConfig = { iceServers: [] };
+
+      const oldPeerConnection = subscriber['pc'];
+      vi.spyOn(oldPeerConnection, 'getReceivers').mockReturnValue([]);
+
+      await subscriber.migrateTo(newSfuClient, newConnectionConfig);
+      const newPeerConnection = subscriber['pc'];
+
+      expect(subscriber['sfuClient']).toBe(newSfuClient);
+      expect(newPeerConnection).not.toBe(oldPeerConnection);
+    });
+
+    it('should close the old peer connection once the new one connects', async () => {
+      let onConnectionStateChange: () => void = () => {};
+      let onTrack: (e: RTCTrackEvent) => void = () => {};
+      // @ts-ignore
+      vi.spyOn(subscriber, 'createPeerConnection').mockImplementation(() => {
+        const pc = new RTCPeerConnection();
+        vi.spyOn(pc, 'addEventListener').mockImplementation((event, cb) => {
+          if (event === 'connectionstatechange') {
+            // @ts-ignore
+            onConnectionStateChange = cb;
+          } else if (event === 'track') {
+            // @ts-ignore
+            onTrack = cb;
+          }
+        });
+        return pc;
+      });
+
+      const oldPeerConnection = subscriber['pc'];
+      vi.spyOn(oldPeerConnection, 'getReceivers').mockReturnValue([]);
+      vi.spyOn(oldPeerConnection, 'close');
+
+      await subscriber.migrateTo(sfuClient, { iceServers: [] });
+
+      const newPeerConnection = subscriber['pc'];
+      vi.spyOn(newPeerConnection, 'removeEventListener');
+      // @ts-ignore
+      newPeerConnection.connectionState = 'connected';
+
+      expect(onConnectionStateChange).toBeDefined();
+      expect(oldPeerConnection.close).not.toHaveBeenCalled();
+      onConnectionStateChange();
+
+      // @ts-ignore
+      onTrack(
+        // @ts-ignore
+        new RTCTrackEvent('video', {
+          track: new MediaStreamTrack(),
+        }),
+      );
+
+      expect(newPeerConnection.removeEventListener).toHaveBeenCalledWith(
+        'connectionstatechange',
+        onConnectionStateChange,
+      );
+      expect(newPeerConnection.removeEventListener).toHaveBeenCalledWith(
+        'track',
+        onTrack,
+      );
+      expect(oldPeerConnection.close).toHaveBeenCalled();
+    });
+  });
+});

package/src/rtc/__tests__/mocks/webrtc.mocks.ts

@@ -3,8 +3,18 @@ import { vi } from 'vitest';
 const RTCPeerConnectionMock = vi.fn((): Partial<RTCPeerConnection> => {
   return {
     addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
     getTransceivers: vi.fn(),
     addTransceiver: vi.fn(),
+    getConfiguration: vi.fn(),
+    setConfiguration: vi.fn(),
+    createOffer: vi.fn().mockResolvedValue({}),
+    createAnswer: vi.fn().mockResolvedValue({}),
+    setLocalDescription: vi.fn().mockResolvedValue({}),
+    setRemoteDescription: vi.fn().mockResolvedValue({}),
+    close: vi.fn(),
+    connectionState: 'connected',
+    getReceivers: vi.fn(),
   };
 });
 vi.stubGlobal('RTCPeerConnection', RTCPeerConnectionMock);
@@ -40,3 +50,13 @@ const RTCRtpTransceiverMock = vi.fn((): Partial<RTCRtpTransceiver> => {
   };
 });
 vi.stubGlobal('RTCRtpTransceiver', RTCRtpTransceiverMock);
+
+const RTCTrackEvent = vi.fn(
+  (type: string, eventInitDict: RTCTrackEventInit): Partial<RTCTrackEvent> => {
+    return {
+      type,
+      ...eventInitDict,
+    };
+  },
+);
+vi.stubGlobal('RTCTrackEvent', RTCTrackEvent);

package/src/rtc/flows/join.ts

@@ -3,7 +3,12 @@ import {
   JoinCallRequest,
   JoinCallResponse,
 } from '../../gen/coordinator';
-import { JoinCallData } from '../../types';
+import {
+  isStreamVideoLocalParticipant,
+  JoinCallData,
+  StreamVideoLocalParticipant,
+  StreamVideoParticipant,
+} from '../../types';
 import { StreamClient } from '../../coordinator/connection/client';
 import { getLogger } from '../../logger';
 
@@ -51,6 +56,10 @@ const doJoin = async (
   // FIXME OL: remove this once cascading is enabled by default
   const cascadingModeParams = getCascadingModeParams();
   if (cascadingModeParams) {
+    // FIXME OL: remove after SFU migration is done
+    if (data?.migrating_from && cascadingModeParams['next_sfu_id']) {
+      cascadingModeParams['sfu_id'] = cascadingModeParams['next_sfu_id'];
+    }
     return httpClient.doAxiosRequest<JoinCallResponse, JoinCallRequest>(
       'post',
       `/call/${type}/${id}/join`,
@@ -103,7 +112,7 @@ const toRtcConfiguration = (config?: ICEServer[]) => {
 
 const getCascadingModeParams = () => {
   if (typeof window === 'undefined') return null;
-  const params = new URLSearchParams(window.location?.search);
+  const params = new URLSearchParams(window.location.search);
   const cascadingEnabled = params.get('cascading') !== null;
   if (cascadingEnabled) {
     const rawParams: Record<string, string> = {};
@@ -114,3 +123,35 @@ const getCascadingModeParams = () => {
   }
   return null;
 };
+
+/**
+ * Reconciles the local state of the source participant into the target participant.
+ *
+ * @param target the participant to reconcile into.
+ * @param source the participant to reconcile from.
+ */
+export const reconcileParticipantLocalState = (
+  target: StreamVideoParticipant | StreamVideoLocalParticipant,
+  source?: StreamVideoParticipant | StreamVideoLocalParticipant,
+) => {
+  if (!source) return target;
+
+  target.audioStream = source.audioStream;
+  target.videoStream = source.videoStream;
+  target.screenShareStream = source.screenShareStream;
+
+  target.videoDimension = source.videoDimension;
+  target.screenShareDimension = source.screenShareDimension;
+  target.pinnedAt = source.pinnedAt;
+  target.reaction = source.reaction;
+  target.viewportVisibilityState = source.viewportVisibilityState;
+  if (
+    isStreamVideoLocalParticipant(source) &&
+    isStreamVideoLocalParticipant(target)
+  ) {
+    target.audioDeviceId = source.audioDeviceId;
+    target.videoDeviceId = source.videoDeviceId;
+    target.audioOutputDeviceId = source.audioOutputDeviceId;
+  }
+  return target;
+};

package/src/rtc/index.ts

@@ -1,7 +1,7 @@
 export * from './codecs';
 export * from './Dispatcher';
 export * from './IceTrickleBuffer';
-export * from './publisher';
-export * from './subscriber';
+export * from './Publisher';
+export * from './Subscriber';
 export * from './signal';
 export * from './videoLayers';

package/src/rtc/signal.ts

@@ -1,3 +1,4 @@
+import WebSocket from 'isomorphic-ws';
 import { SfuEvent } from '../gen/video/sfu/event/events';
 import { getLogger } from '../logger';
 
@@ -11,15 +12,15 @@ export const createWebSocketSignalChannel = (opts: {
   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);
   });
 
   ws.addEventListener('close', (e) => {
-    logger?.('info', 'Signaling WS channel is closed', e);
+    logger('info', 'Signaling WS channel is closed', e);
   });
 
   ws.addEventListener('open', (e) => {
-    logger?.('info', 'Signaling WS channel is open', e);
+    logger('info', 'Signaling WS channel is open', e);
   });
 
   if (onMessage) {
@@ -28,11 +29,11 @@ export const createWebSocketSignalChannel = (opts: {
         const message =
           e.data instanceof ArrayBuffer
             ? SfuEvent.fromBinary(new Uint8Array(e.data))
-            : SfuEvent.fromJsonString(e.data);
+            : SfuEvent.fromJsonString(e.data.toString());
 
         onMessage(message);
       } catch (err) {
-        logger?.(
+        logger(
           'error',
           'Failed to decode a message. Check whether the Proto models match.',
           { event: e, error: err },