@stream-io/video-client 0.0.13 → 0.0.15

package/dist/src/Call.d.ts

@@ -5,7 +5,7 @@ import { AcceptCallResponse, BlockUserResponse, EndCallResponse, GetCallResponse
 import { CallConstructor, CallLeaveOptions, DebounceType, JoinCallData, PublishOptions, SubscriptionChanges } from './types';
 import { ViewportTracker } from './helpers/ViewportTracker';
 import { PermissionsContext } from './permissions';
-import { CallEventHandler, CallEventTypes, StreamCallEvent } from './coordinator/connection/types';
+import { CallEventHandler, CallEventTypes, Logger, StreamCallEvent } from './coordinator/connection/types';
 /**
  * An object representation of a `Call`.
  */
@@ -49,6 +49,7 @@ export declare class Call {
      * The permissions context of this call.
      */
     readonly permissionsContext: PermissionsContext;
+    readonly logger: Logger;
     /**
      * The event dispatcher instance dedicated to this Call instance.
      * @private

package/dist/src/StreamSfuClient.d.ts

@@ -55,6 +55,7 @@ export declare class StreamSfuClient {
     private unhealthyTimeoutInMs;
     private lastMessageTimestamp?;
     private readonly unsubscribeIceTrickle;
+    private readonly logger;
     /**
      * Constructs a new SFU client.
      *

package/dist/src/StreamVideoClient.d.ts

@@ -2,7 +2,7 @@ import { Call } from './Call';
 import { StreamClient } from './coordinator/connection/client';
 import { StreamVideoReadOnlyStateStore } from './store';
 import type { ConnectedEvent, CreateCallTypeRequest, CreateCallTypeResponse, CreateDeviceRequest, CreateGuestRequest, CreateGuestResponse, GetCallTypeResponse, GetEdgesResponse, ListCallTypeResponse, ListDevicesResponse, QueryCallsRequest, UpdateCallTypeRequest, UpdateCallTypeResponse } from './gen/coordinator';
-import type { EventHandler, EventTypes, StreamClientOptions, TokenOrProvider, TokenProvider, User } from './coordinator/connection/types';
+import type { EventHandler, EventTypes, LogLevel, Logger, StreamClientOptions, TokenOrProvider, TokenProvider, User } from './coordinator/connection/types';
 /**
  * A `StreamVideoClient` instance lets you communicate with our API, and authenticate users.
  */
@@ -13,11 +13,14 @@ export declare class StreamVideoClient {
     readonly readOnlyStateStore: StreamVideoReadOnlyStateStore;
     readonly user?: User;
     readonly token?: TokenOrProvider;
+    readonly logLevel: LogLevel;
+    readonly logger: Logger;
     private readonly writeableStateStore;
     streamClient: StreamClient;
     private eventHandlersToUnregister;
     private connectionPromise;
     private disconnectionPromise;
+    private logLevels;
     /**
      * You should create only one instance of `StreamVideoClient`.
      */
@@ -144,4 +147,5 @@ export declare class StreamVideoClient {
      * @param tokenOrProvider a token or a function that returns a token.
      */
     private connectAnonymousUser;
+    private filterLogs;
 }

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

@@ -20,7 +20,7 @@ export type UserWithId = (UserRequest & {
 });
 export type { OwnUserResponse } from '../../gen/coordinator';
 export type ConnectAPIResponse = Promise<void | ConnectedEvent>;
-export type LogLevel = 'info' | 'error' | 'warn';
+export type LogLevel = 'debug' | 'info' | 'error' | 'warn';
 type ErrorResponseDetails = {
     code: number;
     messages: string[];
@@ -59,7 +59,7 @@ export type EventHandler = (event: StreamVideoEvent) => void;
 export type CallEventHandler = (event: StreamCallEvent) => void;
 export type EventTypes = 'all' | StreamVideoEvent['type'];
 export type CallEventTypes = StreamCallEvent['type'];
-export type Logger = (logLevel: LogLevel, message: string, extraData?: Record<string, unknown>) => void;
+export type Logger = (logLevel: LogLevel, message: string, extraData?: any, tags?: string[]) => void;
 export type StreamClientOptions = Partial<AxiosRequestConfig> & {
     /**
      * Used to disable warnings that are triggered by using connectUser or connectAnonymousUser server-side.
@@ -76,6 +76,7 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
     /** experimental feature, please contact support if you want this feature enabled for you */
     enableWSFallback?: boolean;
     logger?: Logger;
+    logLevel?: LogLevel;
     /**
      * When true, user will be persisted on client. Otherwise if `connectUser` call fails, then you need to
      * call `connectUser` again to retry.

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

@@ -1,3 +1,4 @@
+import { Logger } from './types';
 export declare const sleep: (m: number) => Promise<void>;
 export declare function isFunction<T>(value: Function | T): value is Function;
 /**
@@ -21,7 +22,7 @@ export declare function convertErrorToJson(err: Error): Record<string, unknown>;
  * isOnline safely return the navigator.online value for browser env
  * if navigator is not in global object, it always return true
  */
-export declare function isOnline(): boolean;
+export declare function isOnline(logger: Logger): boolean;
 /**
  * listenForConnectionChanges - Adds an event listener fired on browser going online or offline
  */

package/dist/src/logger.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from './coordinator/connection/types';
+export declare const logToConsole: Logger;
+export declare const setLogger: (l: Logger) => void;
+export declare const getLogger: (withTags?: string[]) => Logger;

package/dist/src/rtc/Dispatcher.d.ts

@@ -5,6 +5,8 @@ export declare const isSfuEvent: (eventName: SfuEventKinds | CallEventTypes) =>
 export type SfuEventListener = (event: SfuEvent) => void;
 export declare class Dispatcher {
     private subscribers;
+    private logger?;
+    constructor();
     dispatch: (message: SfuEvent) => void;
     on: (eventName: SfuEventKinds, fn: SfuEventListener) => () => void;
     off: (eventName: SfuEventKinds, fn: SfuEventListener) => void;

package/dist/src/rtc/IceTrickleBuffer.d.ts

@@ -7,5 +7,7 @@ import { ICETrickle } from '../gen/video/sfu/models/models';
 export declare class IceTrickleBuffer {
     readonly subscriberCandidates: ReplaySubject<ICETrickle>;
     readonly publisherCandidates: ReplaySubject<ICETrickle>;
+    private logger?;
+    constructor();
     push: (iceTrickle: ICETrickle) => void;
 }

package/dist/src/rtc/publisher.d.ts

@@ -23,6 +23,7 @@ export declare class Publisher {
     private isDtxEnabled;
     private isRedEnabled;
     private preferredVideoCodec?;
+    private logger?;
     constructor({ connectionConfig, sfuClient, state, isDtxEnabled, isRedEnabled, preferredVideoCodec, }: PublisherOpts);
     /**
      * Starts publishing the given track of the given media stream.

package/dist/src/store/CallState.d.ts

@@ -4,6 +4,7 @@ import { StreamVideoLocalParticipant, StreamVideoParticipant, StreamVideoPartici
 import { CallStatsReport } from '../stats/types';
 import { CallRecording, CallResponse, MemberResponse, OwnCapability, PermissionRequestEvent } from '../gen/coordinator';
 import { Comparator } from '../sorting';
+import { Logger } from '../coordinator/connection/types';
 /**
  * Represents the state of the current call.
  */
@@ -201,6 +202,7 @@ export declare class CallState {
      * The calling state.
      */
     callingState$: Observable<CallingState>;
+    readonly logger: Logger;
     /**
      * A list of comparators that are used to sort the participants.
      *

package/dist/src/types.d.ts

@@ -45,7 +45,7 @@ export interface StreamVideoParticipant extends Participant {
     /**
      * True if the participant is the local participant.
      */
-    isLoggedInUser?: boolean;
+    isLocalParticipant?: boolean;
     /**
      * Timestamp of when the participant is pinned
      */

package/index.ts

@@ -22,3 +22,4 @@ export * from './src/helpers/ViewportTracker';
 export * from './src/helpers/sound-detector';
 export * as Browsers from './src/helpers/browsers';
 export * from './src/sdk-info';
+export * from './src/logger';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/Call.ts

@@ -100,11 +100,13 @@ import {
   CallEventHandler,
   CallEventTypes,
   EventHandler,
+  Logger,
   StreamCallEvent,
 } from './coordinator/connection/types';
 import { UAParser } from 'ua-parser-js';
 import { getSdkInfo } from './sdk-info';
 import { isReactNative } from './helpers/platforms';
+import { getLogger } from './logger';
 
 /**
  * An object representation of a `Call`.
@@ -160,6 +162,7 @@ export class Call {
    * The permissions context of this call.
    */
   readonly permissionsContext = new PermissionsContext();
+  readonly logger: Logger;
 
   /**
    * The event dispatcher instance dedicated to this Call instance.
@@ -220,6 +223,7 @@ export class Call {
     this.streamClient = streamClient;
     this.clientStore = clientStore;
     this.streamClientBasePath = `/call/${this.type}/${this.id}`;
+    this.logger = getLogger(['call']);
 
     const callTypeConfig = CallTypes.get(type);
     const participantSorter =
@@ -280,7 +284,7 @@ export class Call {
           );
           if (!hasPermission && this.publisher.isPublishing(trackType)) {
             this.stopPublish(trackType).catch((err) => {
-              console.error('Error stopping publish', trackType, err);
+              this.logger('error', `Error stopping publish ${trackType}`, err);
             });
           }
         }
@@ -579,6 +583,12 @@ export class Call {
       throw new Error(`Illegal State: Already joined.`);
     }
 
+    if (this.state.callingState === CallingState.LEFT) {
+      throw new Error(
+        'Illegal State: Cannot join already left call. Create a new Call instance to join a call.',
+      );
+    }
+
     const previousCallingState = this.state.callingState;
     this.state.setCallingState(CallingState.JOINING);
 
@@ -641,7 +651,10 @@ export class Call {
      * A closure which hides away the re-connection logic.
      */
     const rejoin = async () => {
-      console.log(`Rejoining call ${this.cid} (${this.reconnectAttempts})...`);
+      this.logger(
+        'debug',
+        `Rejoining call ${this.cid} (${this.reconnectAttempts})...`,
+      );
       this.reconnectAttempts++;
       this.state.setCallingState(CallingState.RECONNECTING);
 
@@ -656,7 +669,7 @@ export class Call {
 
       await sleep(retryInterval(this.reconnectAttempts));
       await this.join(data);
-      console.log(`Rejoin: ${this.reconnectAttempts} successful!`);
+      this.logger('info', `Rejoin: ${this.reconnectAttempts} successful!`);
       if (localParticipant && !isReactNative()) {
         const {
           audioStream,
@@ -669,7 +682,7 @@ export class Call {
         if (videoStream) await this.publishVideoStream(videoStream);
         if (screenShare) await this.publishScreenShareStream(screenShare);
       }
-      console.log(`Rejoin: state restored ${this.reconnectAttempts}`);
+      this.logger('info', `Rejoin: state restored ${this.reconnectAttempts}`);
     };
 
     this.rejoinPromise = rejoin;
@@ -688,13 +701,14 @@ export class Call {
         if (isReactNative()) return;
         if (this.reconnectAttempts < this.maxReconnectAttempts) {
           rejoin().catch(() => {
-            console.log(
+            this.logger(
+              'error',
               `Rejoin failed for ${this.reconnectAttempts} times. Giving up.`,
             );
             this.state.setCallingState(CallingState.RECONNECTING_FAILED);
           });
         } else {
-          console.log('Reconnect attempts exceeded. Giving up...');
+          this.logger('error', 'Reconnect attempts exceeded. Giving up...');
           this.state.setCallingState(CallingState.RECONNECTING_FAILED);
         }
       });
@@ -705,16 +719,17 @@ export class Call {
     if (typeof window !== 'undefined' && window.addEventListener) {
       const handleOnOffline = () => {
         window.removeEventListener('offline', handleOnOffline);
-        console.log('Join: Going offline...');
+        this.logger('warn', 'Join: Going offline...');
         this.state.setCallingState(CallingState.OFFLINE);
       };
 
       const handleOnOnline = () => {
         window.removeEventListener('online', handleOnOnline);
         if (this.state.callingState === CallingState.OFFLINE) {
-          console.log('Join: Going online...');
+          this.logger('info', 'Join: Going online...');
           rejoin().catch(() => {
-            console.log(
+            this.logger(
+              'error',
               `Rejoin failed for ${this.reconnectAttempts} times. Giving up.`,
             );
             this.state.setCallingState(CallingState.RECONNECTING_FAILED);
@@ -783,7 +798,7 @@ export class Call {
       clientDetails.sdk = getSdkInfo();
       // 1. wait for the signal server to be ready before sending "joinRequest"
       sfuClient.signalReady
-        .catch((err) => console.warn('Signal ready failed', err))
+        .catch((err) => this.logger('error', 'Signal ready failed', err))
         // prepare a generic SDP and send it to the SFU.
         // this is a throw-away SDP that the SFU will use to determine
         // the capabilities of the client (codec support, etc.)
@@ -794,12 +809,15 @@ export class Call {
             this.streamClient.options.preferredVideoCodec,
           ),
         )
-        .then((sdp) =>
-          sfuClient.join({
+        .then((sdp) => {
+          const joinRequest = {
             subscriberSdp: sdp || '',
             clientDetails,
-          }),
-        );
+          };
+          this.logger('info', 'Sending join request to SFU');
+          this.logger('debug', 'Join request payload', joinRequest);
+          sfuClient.join(joinRequest);
+        });
 
       // 2. in parallel, wait for the SFU to send us the "joinResponse"
       // this will throw an error if the SFU rejects the join request or
@@ -813,7 +831,7 @@ export class Call {
       this.state.setParticipants(
         currentParticipants.map<StreamVideoParticipant>((participant) => ({
           ...participant,
-          isLoggedInUser: participant.sessionId === sfuClient.sessionId,
+          isLocalParticipant: participant.sessionId === sfuClient.sessionId,
           viewportVisibilityState: VisibilityState.UNKNOWN,
         })),
       );
@@ -823,14 +841,15 @@ export class Call {
 
       this.reconnectAttempts = 0; // reset the reconnect attempts counter
       this.state.setCallingState(CallingState.JOINED);
-      console.log(`Joined call ${this.cid}`);
+      this.logger('info', `Joined call ${this.cid}`);
     } catch (err) {
       // join failed, try to rejoin
       if (this.reconnectAttempts < this.maxReconnectAttempts) {
         await rejoin();
-        console.log(`Rejoin ${this.reconnectAttempts} successful!`);
+        this.logger('info', `Rejoin ${this.reconnectAttempts} successful!`);
       } else {
-        console.log(
+        this.logger(
+          'error',
           `Rejoin failed for ${this.reconnectAttempts} times. Giving up.`,
         );
         this.state.setCallingState(CallingState.RECONNECTING_FAILED);
@@ -862,7 +881,8 @@ export class Call {
 
     const [videoTrack] = videoStream.getVideoTracks();
     if (!videoTrack) {
-      return console.error(`There is no video track in the stream.`);
+      this.logger('error', `There is no video track to publish in the stream.`);
+      return;
     }
 
     await this.publisher.publishStream(
@@ -893,7 +913,8 @@ export class Call {
 
     const [audioTrack] = audioStream.getAudioTracks();
     if (!audioTrack) {
-      return console.error(`There is no audio track in the stream`);
+      this.logger('error', `There is no audio track in the stream to publish`);
+      return;
     }
 
     await this.publisher.publishStream(
@@ -922,7 +943,11 @@ export class Call {
 
     const [screenShareTrack] = screenShareStream.getVideoTracks();
     if (!screenShareTrack) {
-      return console.error(`There is no video track in the stream`);
+      this.logger(
+        'error',
+        `There is no video track in the screen share stream to publish`,
+      );
+      return;
     }
 
     await this.publisher.publishStream(
@@ -942,7 +967,7 @@ export class Call {
    * @param trackType the track type to stop publishing.
    */
   stopPublish = async (trackType: TrackType) => {
-    console.log(`stopPublish`, TrackType[trackType]);
+    this.logger('info', `stopPublish ${TrackType[trackType]}`);
     await this.publisher?.unpublishStream(trackType);
   };
 
@@ -992,7 +1017,7 @@ export class Call {
     const subscriptions: TrackSubscriptionDetails[] = [];
     participants.forEach((p) => {
       // we don't want to subscribe to our own tracks
-      if (p.isLoggedInUser) return;
+      if (p.isLocalParticipant) return;
 
       // NOTE: audio tracks don't have to be requested explicitly
       // as the SFU will implicitly subscribe us to all of them,
@@ -1116,39 +1141,38 @@ export class Call {
     const [primaryStream] = e.streams;
     // example: `e3f6aaf8-b03d-4911-be36-83f47d37a76a:TRACK_TYPE_VIDEO`
     const [trackId, trackType] = primaryStream.id.split(':');
-    console.log(`Got remote ${trackType} track:`, e.track);
+    this.logger('info', `Got remote ${trackType} track:`);
+    this.logger('debug', `Track: `, e.track);
     const participantToUpdate = this.state.participants.find(
       (p) => p.trackLookupPrefix === trackId,
     );
     if (!participantToUpdate) {
-      console.error('Received track for unknown participant', trackId, e);
+      this.logger(
+        'error',
+        `'Received track for unknown participant: ${trackId}'`,
+        e,
+      );
       return;
     }
 
     e.track.addEventListener('mute', () => {
-      console.log(
-        `Track muted:`,
-        participantToUpdate.userId,
-        `${trackType}:${trackId}`,
-        e.track,
+      this.logger(
+        'info',
+        `Track muted: ${participantToUpdate.userId} ${trackType}:${trackId}`,
       );
     });
 
     e.track.addEventListener('unmute', () => {
-      console.log(
-        `Track unmuted:`,
-        participantToUpdate.userId,
-        `${trackType}:${trackId}`,
-        e.track,
+      this.logger(
+        'info',
+        `Track unmuted: ${participantToUpdate.userId} ${trackType}:${trackId}`,
       );
     });
 
     e.track.addEventListener('ended', () => {
-      console.log(
-        `Track ended:`,
-        participantToUpdate.userId,
-        `${trackType}:${trackId}`,
-        e.track,
+      this.logger(
+        'info',
+        `Track ended: ${participantToUpdate.userId} ${trackType}:${trackId}`,
       );
     });
 
@@ -1161,12 +1185,15 @@ export class Call {
     )[trackType];
 
     if (!streamKindProp) {
-      console.error('Unknown track type', trackType);
+      this.logger('error', `Unknown track type: ${trackType}`);
       return;
     }
     const previousStream = participantToUpdate[streamKindProp];
     if (previousStream) {
-      console.log(`Cleaning up previous remote tracks`, e.track.kind);
+      this.logger(
+        'info',
+        `Cleaning up previous remote tracks: ${e.track.kind}`,
+      );
       previousStream.getTracks().forEach((t) => {
         t.stop();
         previousStream.removeTrack(t);

package/src/StreamSfuClient.ts

@@ -1,4 +1,11 @@
-import type { FinishedUnaryCall, UnaryCall } from '@protobuf-ts/runtime-rpc';
+import type {
+  FinishedUnaryCall,
+  MethodInfo,
+  NextUnaryFn,
+  RpcInterceptor,
+  RpcOptions,
+  UnaryCall,
+} from '@protobuf-ts/runtime-rpc';
 import { SignalServerClient } from './gen/video/sfu/signal_rpc/signal.client';
 import { createSignalClient, withHeaders } from './rpc';
 import {
@@ -23,6 +30,8 @@ import {
   retryInterval,
   sleep,
 } from './coordinator/connection/utils';
+import { Logger } from './coordinator/connection/types';
+import { getLogger } from './logger';
 
 export type StreamSfuClientConstructor = {
   /**
@@ -84,6 +93,7 @@ export class StreamSfuClient {
   private unhealthyTimeoutInMs = this.pingIntervalInMs + 5 * 1000;
   private lastMessageTimestamp?: Date;
   private readonly unsubscribeIceTrickle: () => void;
+  private readonly logger: Logger;
 
   /**
    * Constructs a new SFU client.
@@ -103,12 +113,27 @@ export class StreamSfuClient {
   }: StreamSfuClientConstructor) {
     this.sessionId = sessionId || generateUUIDv4();
     this.token = token;
+    this.logger = getLogger(['sfu-client']);
+    const logger = this.logger;
+    const logInterceptor: RpcInterceptor = {
+      interceptUnary(
+        next: NextUnaryFn,
+        method: MethodInfo,
+        input: object,
+        options: RpcOptions,
+      ): UnaryCall {
+        logger('info', `Calling SFU RPC method ${method.name}`);
+        logger('debug', `Method call payload`, { input, options });
+        return next(method, input, options);
+      },
+    };
     this.rpc = createSignalClient({
       baseUrl: url,
       interceptors: [
         withHeaders({
           Authorization: `Bearer ${token}`,
         }),
+        logInterceptor,
       ],
     });
 
@@ -152,38 +177,46 @@ export class StreamSfuClient {
   };
 
   updateSubscriptions = async (subscriptions: TrackSubscriptionDetails[]) => {
-    return retryable(() =>
-      this.rpc.updateSubscriptions({
-        sessionId: this.sessionId,
-        tracks: subscriptions,
-      }),
+    return retryable(
+      () =>
+        this.rpc.updateSubscriptions({
+          sessionId: this.sessionId,
+          tracks: subscriptions,
+        }),
+      this.logger,
     );
   };
 
   setPublisher = async (data: Omit<SetPublisherRequest, 'sessionId'>) => {
-    return retryable(() =>
-      this.rpc.setPublisher({
-        ...data,
-        sessionId: this.sessionId,
-      }),
+    return retryable(
+      () =>
+        this.rpc.setPublisher({
+          ...data,
+          sessionId: this.sessionId,
+        }),
+      this.logger,
     );
   };
 
   sendAnswer = async (data: Omit<SendAnswerRequest, 'sessionId'>) => {
-    return retryable(() =>
-      this.rpc.sendAnswer({
-        ...data,
-        sessionId: this.sessionId,
-      }),
+    return retryable(
+      () =>
+        this.rpc.sendAnswer({
+          ...data,
+          sessionId: this.sessionId,
+        }),
+      this.logger,
     );
   };
 
   iceTrickle = async (data: Omit<ICETrickle, 'sessionId'>) => {
-    return retryable(() =>
-      this.rpc.iceTrickle({
-        ...data,
-        sessionId: this.sessionId,
-      }),
+    return retryable(
+      () =>
+        this.rpc.iceTrickle({
+          ...data,
+          sessionId: this.sessionId,
+        }),
+      this.logger,
     );
   };
 
@@ -201,11 +234,13 @@ export class StreamSfuClient {
   updateMuteStates = async (
     data: Omit<UpdateMuteStatesRequest, 'sessionId'>,
   ) => {
-    return retryable(() =>
-      this.rpc.updateMuteStates({
-        ...data,
-        sessionId: this.sessionId,
-      }),
+    return retryable(
+      () =>
+        this.rpc.updateMuteStates({
+          ...data,
+          sessionId: this.sessionId,
+        }),
+      this.logger,
     );
   };
 
@@ -236,7 +271,7 @@ export class StreamSfuClient {
       clearInterval(this.keepAliveInterval);
     }
     this.keepAliveInterval = setInterval(() => {
-      console.log('Sending healthCheckRequest to SFU');
+      this.logger('info', 'Sending healthCheckRequest to SFU');
       const message = SfuRequest.create({
         requestPayload: {
           oneofKind: 'healthCheckRequest',
@@ -258,7 +293,7 @@ export class StreamSfuClient {
           new Date().getTime() - this.lastMessageTimestamp.getTime();
 
         if (timeSinceLastMessage > this.unhealthyTimeoutInMs) {
-          console.log('SFU connection unhealthy, closing');
+          this.logger('error', 'SFU connection unhealthy, closing');
           this.close(
             4001,
             `SFU connection unhealthy. Didn't receive any healthcheck messages for ${this.unhealthyTimeoutInMs}ms`,
@@ -296,6 +331,7 @@ const MAX_RETRIES = 5;
  */
 const retryable = async <I extends object, O extends SfuResponseWithError>(
   rpc: () => UnaryCall<I, O>,
+  logger: Logger,
 ) => {
   let retryAttempt = 0;
   let rpcCallResult: FinishedUnaryCall<I, O>;
@@ -306,10 +342,15 @@ const retryable = async <I extends object, O extends SfuResponseWithError>(
     }
 
     rpcCallResult = await rpc();
+    logger(
+      'info',
+      `SFU RPC response received for ${rpcCallResult.method.name}`,
+    );
+    logger('debug', `Response payload`, rpcCallResult);
 
     // if the RPC call failed, log the error and retry
     if (rpcCallResult.response.error) {
-      console.error('SFU Error:', rpcCallResult.response.error);
+      logger('error', 'SFU RPC Error:', rpcCallResult.response.error);
     }
     retryAttempt++;
   } while (