@stream-io/video-client 1.35.0 → 1.36.0

package/src/devices/devices.ts

@@ -9,12 +9,12 @@ import {
   startWith,
   tap,
 } from 'rxjs';
-import { getLogger } from '../logger';
 import { BrowserPermission } from './BrowserPermission';
 import { lazy } from '../helpers/lazy';
 import { isFirefox } from '../helpers/browsers';
 import { dumpStream, Tracer } from '../stats';
 import { getCurrentValue } from '../store/rxUtils';
+import { videoLoggerSystem } from '../logger';
 
 /**
  * Returns an Observable that emits the list of available devices
@@ -266,15 +266,16 @@ export const getAudioStream = async (
     if (isNotFoundOrOverconstrainedError(error) && trackConstraints?.deviceId) {
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { deviceId, ...relaxedConstraints } = trackConstraints;
-      getLogger(['devices'])(
-        'warn',
-        'Failed to get audio stream, will try again with relaxed constraints',
-        { error, constraints, relaxedConstraints },
-      );
+      videoLoggerSystem
+        .getLogger('devices')
+        .warn(
+          'Failed to get audio stream, will try again with relaxed constraints',
+          { error, constraints, relaxedConstraints },
+        );
       return getAudioStream(relaxedConstraints);
     }
 
-    getLogger(['devices'])('error', 'Failed to get audio stream', {
+    videoLoggerSystem.getLogger('devices').error('Failed to get audio stream', {
       error,
       constraints,
     });
@@ -310,15 +311,16 @@ export const getVideoStream = async (
     if (isNotFoundOrOverconstrainedError(error) && trackConstraints?.deviceId) {
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { deviceId, ...relaxedConstraints } = trackConstraints;
-      getLogger(['devices'])(
-        'warn',
-        'Failed to get video stream, will try again with relaxed constraints',
-        { error, constraints, relaxedConstraints },
-      );
+      videoLoggerSystem
+        .getLogger('devices')
+        .warn(
+          'Failed to get video stream, will try again with relaxed constraints',
+          { error, constraints, relaxedConstraints },
+        );
       return getVideoStream(relaxedConstraints);
     }
 
-    getLogger(['devices'])('error', 'Failed to get video stream', {
+    videoLoggerSystem.getLogger('devices').error('Failed to get video stream', {
       error,
       constraints,
     });
@@ -373,7 +375,9 @@ export const getScreenShareStream = async (
     return stream;
   } catch (e) {
     tracer?.trace(`${tag}OnFailure`, (e as Error).name);
-    getLogger(['devices'])('error', 'Failed to get screen share stream', e);
+    videoLoggerSystem
+      .getLogger('devices')
+      .error('Failed to get screen share stream', e);
     throw e;
   }
 };

package/src/events/call.ts

@@ -38,8 +38,7 @@ export const watchCallRejected = (call: Call) => {
     const { session: callSession } = eventCall;
 
     if (!callSession) {
-      call.logger(
-        'warn',
+      call.logger.warn(
         'No call session provided. Ignoring call.rejected event.',
         event,
       );
@@ -49,8 +48,7 @@ export const watchCallRejected = (call: Call) => {
     const rejectedBy = callSession.rejected_by;
     const { members, callingState } = call.state;
     if (callingState !== CallingState.RINGING) {
-      call.logger(
-        'info',
+      call.logger.info(
         'Call is not in ringing mode (it is either accepted or rejected already). Ignoring call.rejected event.',
         event,
       );
@@ -61,7 +59,7 @@ export const watchCallRejected = (call: Call) => {
         .filter((m) => m.user_id !== call.currentUserId)
         .every((m) => rejectedBy[m.user_id]);
       if (everyoneElseRejected) {
-        call.logger('info', 'everyone rejected, leaving the call');
+        call.logger.info('everyone rejected, leaving the call');
         await call.leave({
           reject: true,
           reason: 'cancel',
@@ -70,7 +68,7 @@ export const watchCallRejected = (call: Call) => {
       }
     } else {
       if (rejectedBy[eventCall.created_by.id]) {
-        call.logger('info', 'call creator rejected, leaving call');
+        call.logger.info('call creator rejected, leaving call');
         await call.leave({ message: 'ring: creator rejected' });
       }
     }
@@ -90,7 +88,7 @@ export const watchCallEnded = (call: Call) => {
       call
         .leave({ message: 'call.ended event received', reject: false })
         .catch((err) => {
-          call.logger('error', 'Failed to leave call after call.ended ', err);
+          call.logger.error('Failed to leave call after call.ended ', err);
         });
     }
   };
@@ -117,8 +115,7 @@ export const watchSfuCallEnded = (call: Call) => {
       const reason = CallEndedReason[e.reason];
       await call.leave({ message: `callEnded received: ${reason}` });
     } catch (err) {
-      call.logger(
-        'error',
+      call.logger.error(
         'Failed to leave call after being ended by the SFU',
         err,
       );

package/src/events/internal.ts

@@ -2,7 +2,6 @@ import { Dispatcher } from '../rtc';
 import { Call } from '../Call';
 import { CallState } from '../store';
 import { StreamVideoParticipantPatches } from '../types';
-import { getLogger } from '../logger';
 import { pushToIfMissing, removeFromIfPresent } from '../helpers/array';
 import type {
   InboundStateNotification,
@@ -13,6 +12,7 @@ import {
   WebsocketReconnectStrategy,
 } from '../gen/video/sfu/models/models';
 import { OwnCapability } from '../gen/coordinator';
+import { videoLoggerSystem } from '../logger';
 
 export const watchConnectionQualityChanged = (
   dispatcher: Dispatcher,
@@ -60,7 +60,7 @@ export const watchLiveEnded = (dispatcher: Dispatcher, call: Call) => {
     call.state.setBackstage(true);
     if (!call.permissionsContext.hasPermission(OwnCapability.JOIN_BACKSTAGE)) {
       call.leave({ message: 'live ended' }).catch((err) => {
-        call.logger('error', 'Failed to leave call after live ended', err);
+        call.logger.error('Failed to leave call after live ended', err);
       });
     }
   });
@@ -72,9 +72,9 @@ export const watchLiveEnded = (dispatcher: Dispatcher, call: Call) => {
 export const watchSfuErrorReports = (dispatcher: Dispatcher) => {
   return dispatcher.on('error', (e) => {
     if (!e.error) return;
-    const logger = getLogger(['SfuClient']);
+    const logger = videoLoggerSystem.getLogger('SfuClient');
     const { error, reconnectStrategy } = e;
-    logger('error', 'SFU reported error', {
+    logger.error('SFU reported error', {
       code: ErrorCode[error.code],
       reconnectStrategy: WebsocketReconnectStrategy[reconnectStrategy],
       message: error.message,

package/src/events/mutes.ts

@@ -18,8 +18,7 @@ export const handleRemoteSoftMute = (call: Call) => {
       sessionId === localParticipant?.sessionId
     ) {
       const logger = call.logger;
-      logger(
-        'info',
+      logger.info(
         `Local participant's ${TrackType[type]} track is muted remotely`,
       );
       try {
@@ -33,14 +32,10 @@ export const handleRemoteSoftMute = (call: Call) => {
         ) {
           await call.screenShare.disable();
         } else {
-          logger(
-            'warn',
-            'Unsupported track type to soft mute',
-            TrackType[type],
-          );
+          logger.warn('Unsupported track type to soft mute', TrackType[type]);
         }
       } catch (error) {
-        logger('error', 'Failed to stop publishing', error);
+        logger.error('Failed to stop publishing', error);
       }
     }
   });

package/src/helpers/DynascaleManager.ts

@@ -15,7 +15,6 @@ import {
   takeWhile,
 } from 'rxjs';
 import { ViewportTracker } from './ViewportTracker';
-import { getLogger } from '../logger';
 import { isFirefox, isSafari } from './browsers';
 import {
   hasScreenShare,
@@ -27,6 +26,7 @@ import type { CallState } from '../store';
 import type { StreamSfuClient } from '../StreamSfuClient';
 import { SpeakerManager } from '../devices';
 import { getCurrentValue, setCurrentValue } from '../store/rxUtils';
+import { videoLoggerSystem } from '../logger';
 
 const DEFAULT_VIEWPORT_VISIBILITY_STATE: Record<
   VideoTrackType,
@@ -66,7 +66,7 @@ export class DynascaleManager {
    */
   readonly viewportTracker = new ViewportTracker();
 
-  private logger = getLogger(['DynascaleManager']);
+  private logger = videoLoggerSystem.getLogger('DynascaleManager');
   private callState: CallState;
   private speaker: SpeakerManager;
   private audioContext: AudioContext | undefined;
@@ -212,7 +212,7 @@ export class DynascaleManager {
       this.sfuClient
         ?.updateSubscriptions(this.trackSubscriptions)
         .catch((err: unknown) => {
-          this.logger('debug', `Failed to update track subscriptions`, err);
+          this.logger.debug(`Failed to update track subscriptions`, err);
         });
     };
 
@@ -324,7 +324,7 @@ export class DynascaleManager {
         // is not visible (e.g., has display: none).
         // we treat this as "unsubscription" as we don't want to keep
         // consuming bandwidth for a video that is not visible on the screen.
-        this.logger('debug', `Ignoring 0x0 dimension`, boundParticipant);
+        this.logger.debug(`Ignoring 0x0 dimension`, boundParticipant);
         dimension = undefined;
       }
       this.callState.updateParticipantTracks(trackType, {
@@ -468,7 +468,7 @@ export class DynascaleManager {
           setTimeout(() => {
             videoElement.srcObject = source ?? null;
             videoElement.play().catch((e) => {
-              this.logger('warn', `Failed to play stream`, e);
+              this.logger.warn(`Failed to play stream`, e);
             });
             // we add extra delay until we attempt to force-play
             // the participant's media stream in Firefox and Safari,
@@ -519,14 +519,14 @@ export class DynascaleManager {
       if (!deviceId) return;
       if ('setSinkId' in audioElement) {
         audioElement.setSinkId(deviceId).catch((e) => {
-          this.logger('warn', `Can't to set AudioElement sinkId`, e);
+          this.logger.warn(`Can't to set AudioElement sinkId`, e);
         });
       }
 
       if (audioContext && 'setSinkId' in audioContext) {
         // @ts-expect-error setSinkId is not available in all browsers
         audioContext.setSinkId(deviceId).catch((e) => {
-          this.logger('warn', `Can't to set AudioContext sinkId`, e);
+          this.logger.warn(`Can't to set AudioContext sinkId`, e);
         });
       }
     };
@@ -574,7 +574,7 @@ export class DynascaleManager {
             // we will play audio directly through the audio element in other browsers
             audioElement.muted = false;
             audioElement.play().catch((e) => {
-              this.logger('warn', `Failed to play audio stream`, e);
+              this.logger.warn(`Failed to play audio stream`, e);
             });
           }
 
@@ -630,7 +630,7 @@ export class DynascaleManager {
     if (this.audioContext?.state === 'suspended') {
       this.audioContext
         .resume()
-        .catch((err) => this.logger('warn', `Can't resume audio context`, err))
+        .catch((err) => this.logger.warn(`Can't resume audio context`, err))
         .then(() => {
           document.removeEventListener('click', this.resumeAudioContext);
         });

package/src/helpers/RNSpeechDetector.ts

@@ -1,7 +1,7 @@
 import { BaseStats } from '../stats';
 import { SoundStateChangeHandler } from './sound-detector';
 import { flatten } from '../stats/utils';
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 export class RNSpeechDetector {
   private pc1 = new RTCPeerConnection({});
@@ -64,8 +64,8 @@ export class RNSpeechDetector {
         this.stop();
       };
     } catch (error) {
-      const logger = getLogger(['RNSpeechDetector']);
-      logger('error', 'error handling permissions: ', error);
+      const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
+      logger.error('error handling permissions: ', error);
       return () => {};
     }
   }
@@ -164,8 +164,8 @@ export class RNSpeechDetector {
           }
         }
       } catch (error) {
-        const logger = getLogger(['RNSpeechDetector']);
-        logger('error', 'error checking audio level from stats', error);
+        const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
+        logger.error('error checking audio level from stats', error);
       }
     };
 

package/src/helpers/clientUtils.ts

@@ -4,7 +4,6 @@ import type {
   TokenOrProvider,
   User,
 } from '../coordinator/connection/types';
-import { getLogger } from '../logger';
 import { StreamClient } from '../coordinator/connection/client';
 import { getSdkInfo } from './client-details';
 import { SdkType } from '../gen/video/sfu/models/models';
@@ -50,12 +49,11 @@ export const createCoordinatorClient = (
   options: StreamClientOptions | undefined,
 ) => {
   const clientAppIdentifier = getClientAppIdentifier(options);
-  const coordinatorLogger = getLogger(['coordinator']);
+
   return new StreamClient(apiKey, {
     persistUserOnConnectionFailure: true,
     ...options,
     clientAppIdentifier,
-    logger: coordinatorLogger,
   });
 };
 

package/src/helpers/ensureExhausted.ts

@@ -1,5 +1,5 @@
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 export const ensureExhausted = (x: never, message: string) => {
-  getLogger(['helpers'])('warn', message, x);
+  videoLoggerSystem.getLogger('helpers').warn(message, x);
 };

package/src/logger.ts

@@ -1,17 +1,6 @@
-import { Logger, LogLevel } from './coordinator/connection/types';
+import * as scopedLogger from '@stream-io/logger';
 import { isReactNative } from './helpers/platforms';
-
-// log levels, sorted by verbosity
-export const logLevels: Record<LogLevel, number> = Object.freeze({
-  trace: 0,
-  debug: 1,
-  info: 2,
-  warn: 3,
-  error: 4,
-});
-
-let logger: Logger | undefined;
-let level: LogLevel = 'info';
+import type { Logger } from './coordinator/connection/types';
 
 export const logToConsole: Logger = (logLevel, message, ...args) => {
   let logMethod;
@@ -46,26 +35,12 @@ export const logToConsole: Logger = (logLevel, message, ...args) => {
   logMethod(message, ...args);
 };
 
-export const setLogger = (l: Logger, lvl?: LogLevel) => {
-  logger = l;
-  if (lvl) {
-    setLogLevel(lvl);
-  }
-};
+/**
+ * @internal
+ */
+export type ScopedLogger = scopedLogger.Logger;
 
-export const setLogLevel = (l: LogLevel) => {
-  level = l;
-};
-
-export const getLogLevel = (): LogLevel => level;
+export { LogLevelEnum } from '@stream-io/logger';
+export type { LogLevel, Sink } from '@stream-io/logger';
 
-export const getLogger = (withTags?: string[]) => {
-  const loggerMethod = logger || logToConsole;
-  const tags = (withTags || []).filter(Boolean).join(':');
-  const result: Logger = (logLevel, message, ...args) => {
-    if (logLevels[logLevel] >= logLevels[level]) {
-      loggerMethod(logLevel, `[${tags}]: ${message}`, ...args);
-    }
-  };
-  return result;
-};
+export const videoLoggerSystem = scopedLogger.createLoggerSystem();

package/src/rpc/__tests__/createClient.test.ts

@@ -8,6 +8,7 @@ import {
 import { TwirpFetchTransport } from '@protobuf-ts/twirp-transport';
 import { NextUnaryFn, UnaryCall } from '@protobuf-ts/runtime-rpc';
 import { promiseWithResolvers } from '../../helpers/promise';
+import { ScopedLogger } from '../../logger';
 
 describe('createClient', () => {
   it('should create a client with TwirpFetchTransport', () => {
@@ -30,7 +31,10 @@ describe('createClient', () => {
 
   it('withRequestLogger should log the request', () => {
     const logger = vi.fn();
-    const interceptor = withRequestLogger(logger, 'debug');
+    const interceptor = withRequestLogger(
+      { debug: logger } as unknown as ScopedLogger,
+      'debug',
+    );
     const next = vi.fn().mockReturnValue({});
     // @ts-expect-error - private field
     interceptor.interceptUnary(next, { name: 'test' }, null, null);

package/src/rpc/createClient.ts

@@ -10,9 +10,10 @@ import {
   TwirpOptions,
 } from '@protobuf-ts/twirp-transport';
 import { SignalServerClient } from '../gen/video/sfu/signal_rpc/signal.client';
-import { Logger, LogLevel } from '../coordinator/connection/types';
 import type { Trace } from '../stats';
 import type { SfuResponseWithError } from './retryable';
+import type { ScopedLogger } from '../logger';
+import type { LogLevel } from '@stream-io/logger';
 
 const defaultOptions: TwirpOptions = {
   baseUrl: '',
@@ -40,7 +41,7 @@ export const withHeaders = (
 };
 
 export const withRequestLogger = (
-  logger: Logger,
+  logger: ScopedLogger,
   level: LogLevel,
 ): RpcInterceptor => {
   return {
@@ -51,7 +52,7 @@ export const withRequestLogger = (
       options: RpcOptions,
     ): UnaryCall => {
       const invocation = next(method, input, options);
-      logger(level, `Invoked SFU RPC method ${method.name}`, {
+      logger[level](`Invoked SFU RPC method ${method.name}`, {
         request: invocation.request,
         headers: invocation.requestHeaders,
         response: invocation.response,

package/src/rpc/retryable.ts

@@ -6,7 +6,7 @@ import {
 import { TwirpErrorCode } from '@protobuf-ts/twirp-transport';
 import { retryInterval, sleep } from '../coordinator/connection/utils';
 import { Error as SfuError } from '../gen/video/sfu/models/models';
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 /**
  * An internal interface which asserts that "retryable" SFU responses
@@ -48,7 +48,9 @@ export const retryable = async <
         err.code === TwirpErrorCode[TwirpErrorCode.cancelled];
       const isAborted = signal?.aborted ?? false;
       if (isRequestCancelled || isAborted) throw err;
-      getLogger(['sfu-client', 'rpc'])('debug', `rpc failed (${attempt})`, err);
+      videoLoggerSystem
+        .getLogger('sfu-client', { tags: ['rpc'] })
+        .debug(`rpc failed (${attempt})`, err);
       attempt++;
     }
   } while (!result || result.response.error?.shouldRetry);

package/src/rtc/BasePeerConnection.ts

@@ -1,8 +1,5 @@
-import { getLogger } from '../logger';
-import type {
-  CallEventListener,
-  Logger,
-} from '../coordinator/connection/types';
+import { ScopedLogger, videoLoggerSystem } from '../logger';
+import type { CallEventListener } from '../coordinator/connection/types';
 import { CallingState, CallState } from '../store';
 import { createSafeAsyncSubscription } from '../store/rxUtils';
 import {
@@ -23,7 +20,7 @@ import { BasePeerConnectionOpts, OnReconnectionNeeded } from './types';
  * @internal
  */
 export abstract class BasePeerConnection {
-  protected readonly logger: Logger;
+  protected readonly logger: ScopedLogger;
   protected readonly peerType: PeerType;
   protected readonly pc: RTCPeerConnection;
   protected readonly state: CallState;
@@ -67,10 +64,10 @@ export abstract class BasePeerConnection {
     this.dispatcher = dispatcher;
     this.iceRestartDelay = iceRestartDelay;
     this.onReconnectionNeeded = onReconnectionNeeded;
-    this.logger = getLogger([
+    this.logger = videoLoggerSystem.getLogger(
       peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher',
-      tag,
-    ]);
+      { tags: [tag] },
+    );
     this.pc = this.createPeerConnection(connectionConfig);
     this.stats = new StatsTracer(this.pc, peerType, this.trackIdToTrackType);
     if (enableTracing) {
@@ -142,7 +139,7 @@ export abstract class BasePeerConnection {
   protected tryRestartIce = () => {
     this.restartIce().catch((e) => {
       const reason = 'restartICE() failed, initiating reconnect';
-      this.logger('error', reason, e);
+      this.logger.error(reason, e);
       const strategy =
         e instanceof NegotiationError &&
         e.error.code === ErrorCode.PARTICIPANT_SIGNAL_LOST
@@ -165,7 +162,7 @@ export abstract class BasePeerConnection {
         const lockKey = `pc.${this.lock}.${event}`;
         withoutConcurrency(lockKey, async () => fn(e)).catch((err) => {
           if (this.isDisposed) return;
-          this.logger('warn', `Error handling ${event}`, err);
+          this.logger.warn(`Error handling ${event}`, err);
         });
       }),
     );
@@ -187,7 +184,7 @@ export abstract class BasePeerConnection {
       async (candidate) => {
         return this.pc.addIceCandidate(candidate).catch((e) => {
           if (this.isDisposed) return;
-          this.logger('warn', `ICE candidate error`, e, candidate);
+          this.logger.warn(`ICE candidate error`, e, candidate);
         });
       },
     );
@@ -240,7 +237,7 @@ export abstract class BasePeerConnection {
   private onIceCandidate = (e: RTCPeerConnectionIceEvent) => {
     const { candidate } = e;
     if (!candidate) {
-      this.logger('debug', 'null ice candidate');
+      this.logger.debug('null ice candidate');
       return;
     }
 
@@ -249,7 +246,7 @@ export abstract class BasePeerConnection {
       .iceTrickle({ peerType: this.peerType, iceCandidate })
       .catch((err) => {
         if (this.isDisposed) return;
-        this.logger('warn', `ICETrickle failed`, err);
+        this.logger.warn(`ICETrickle failed`, err);
       });
   };
 
@@ -272,7 +269,7 @@ export abstract class BasePeerConnection {
    */
   private onConnectionStateChange = async () => {
     const state = this.pc.connectionState;
-    this.logger('debug', `Connection state changed`, state);
+    this.logger.debug(`Connection state changed`, state);
     if (this.tracer && (state === 'connected' || state === 'failed')) {
       try {
         const stats = await this.stats.get();
@@ -299,7 +296,7 @@ export abstract class BasePeerConnection {
    */
   private onIceConnectionStateChange = () => {
     const state = this.pc.iceConnectionState;
-    this.logger('debug', `ICE connection state changed`, state);
+    this.logger.debug(`ICE connection state changed`, state);
     this.handleConnectionStateUpdate(state);
   };
 
@@ -316,14 +313,14 @@ export abstract class BasePeerConnection {
     switch (state) {
       case 'failed':
         // in the `failed` state, we try to restart ICE immediately
-        this.logger('info', 'restartICE due to failed connection');
+        this.logger.info('restartICE due to failed connection');
         this.tryRestartIce();
         break;
 
       case 'disconnected':
         // in the `disconnected` state, we schedule a restartICE() after a delay
         // as the browser might recover the connection in the meantime
-        this.logger('info', 'disconnected connection, scheduling restartICE');
+        this.logger.info('disconnected connection, scheduling restartICE');
         clearTimeout(this.iceRestartTimeout);
         this.iceRestartTimeout = setTimeout(() => {
           const currentState = this.pc.iceConnectionState;
@@ -336,7 +333,7 @@ export abstract class BasePeerConnection {
       case 'connected':
         // in the `connected` state, we clear the ice restart timeout if it exists
         if (this.iceRestartTimeout) {
-          this.logger('info', 'connected connection, canceling restartICE');
+          this.logger.info('connected connection, canceling restartICE');
           clearTimeout(this.iceRestartTimeout);
           this.iceRestartTimeout = undefined;
         }
@@ -352,20 +349,20 @@ export abstract class BasePeerConnection {
       e instanceof RTCPeerConnectionIceErrorEvent
         ? `${e.errorCode}: ${e.errorText}`
         : e;
-    this.logger('debug', 'ICE Candidate error', errorMessage);
+    this.logger.debug('ICE Candidate error', errorMessage);
   };
 
   /**
    * Handles the ICE gathering state change event.
    */
   private onIceGatherChange = () => {
-    this.logger('debug', `ICE Gathering State`, this.pc.iceGatheringState);
+    this.logger.debug(`ICE Gathering State`, this.pc.iceGatheringState);
   };
 
   /**
    * Handles the signaling state change event.
    */
   private onSignalingChange = () => {
-    this.logger('debug', `Signaling state changed`, this.pc.signalingState);
+    this.logger.debug(`Signaling state changed`, this.pc.signalingState);
   };
 }

package/src/rtc/Dispatcher.ts

@@ -1,6 +1,6 @@
 import { CallEventListener, EventTypes } from '../coordinator/connection/types';
 import type { SfuEvent } from '../gen/video/sfu/event/events';
-import { getLogger } from '../logger';
+import { videoLoggerSystem } from '../logger';
 
 export type SfuEventKinds = NonNullable<SfuEvent['eventPayload']['oneofKind']>;
 export type AllSfuEvents = {
@@ -53,7 +53,7 @@ export const isSfuEvent = (
 };
 
 export class Dispatcher {
-  private readonly logger = getLogger(['Dispatcher']);
+  private readonly logger = videoLoggerSystem.getLogger('Dispatcher');
   private subscribers: Partial<
     Record<SfuEventKinds, CallEventListener<any>[] | undefined>
   > = {};
@@ -65,14 +65,14 @@ export class Dispatcher {
     const eventKind = message.eventPayload.oneofKind;
     if (!eventKind) return;
     const payload = message.eventPayload[eventKind];
-    this.logger('debug', `Dispatching ${eventKind}, tag=${tag}`, payload);
+    this.logger.debug(`Dispatching ${eventKind}, tag=${tag}`, payload);
     const listeners = this.subscribers[eventKind];
     if (!listeners) return;
     for (const fn of listeners) {
       try {
         fn(payload);
       } catch (e) {
-        this.logger('warn', 'Listener failed with error', e);
+        this.logger.warn('Listener failed with error', e);
       }
     }
   };