feat: Migrate logger to js-toolkit logger implementation (#1959)

### 💡 Overview

- Migrated usage of `getLogger` to new syntax where the first tag is
considered as scope and the subsequent are tags.

- Introduced new configuration option: `logOptions?:
ConfigureLoggersOptions<string>` which allows the consumers to configure
the loggers per scope

- Marked `logger` and `logLevel` as deprecated and in first
implementation setting them as default `level` and `level` in
`configureLoggers`


### 📝 Implementation notes


📑 Docs: [GetStream/docs-content#673]

Author: jdimovska

packages/client/package.json

@@ -29,7 +29,8 @@
     "@protobuf-ts/runtime": "^2.11.1",
     "@protobuf-ts/runtime-rpc": "^2.11.1",
     "@protobuf-ts/twirp-transport": "^2.11.1",
-    "@stream-io/worker-timer": "^1.2.4",
+    "@stream-io/logger": "^2.0.0",
+    "@stream-io/worker-timer": "^1.2.5",
     "axios": "^1.12.2",
     "rxjs": "~7.8.2",
     "sdp-transform": "^2.15.0",

packages/client/src/Call.ts

@@ -25,6 +25,7 @@ import {
   createSubscription,
   getCurrentValue,
 } from './store/rxUtils';
+import { ScopedLogger, videoLoggerSystem } from './logger';
 import type {
   AcceptCallResponse,
   BlockUserRequest,
@@ -139,12 +140,10 @@ import {
   AllCallEvents,
   CallEventListener,
   ErrorFromResponse,
-  Logger,
   RejectReason,
   StreamCallEvent,
 } from './coordinator/connection/types';
 import { getClientDetails } from './helpers/client-details';
-import { getLogger } from './logger';
 import {
   CameraManager,
   MicrophoneManager,
@@ -229,7 +228,7 @@ export class Call {
    */
   readonly permissionsContext = new PermissionsContext();
   readonly tracer = new Tracer(null);
-  readonly logger: Logger;
+  readonly logger: ScopedLogger;
 
   /**
    * The event dispatcher instance dedicated to this Call instance.
@@ -312,7 +311,7 @@ export class Call {
     this.streamClient = streamClient;
     this.clientStore = clientStore;
     this.streamClientBasePath = `/call/${this.type}/${this.id}`;
-    this.logger = getLogger(['Call']);
+    this.logger = videoLoggerSystem.getLogger('Call');
 
     const callTypeConfig = CallTypes.get(type);
     const participantSorter =
@@ -396,9 +395,9 @@ export class Call {
         if (!blockedUserIds || blockedUserIds.length === 0) return;
         const currentUserId = this.currentUserId;
         if (currentUserId && blockedUserIds.includes(currentUserId)) {
-          this.logger('info', 'Leaving call because of being blocked');
+          this.logger.info('Leaving call because of being blocked');
           await this.leave({ message: 'user blocked' }).catch((err) => {
-            this.logger('error', 'Error leaving call after being blocked', err);
+            this.logger.error('Error leaving call after being blocked', err);
           });
         }
       }),
@@ -442,8 +441,7 @@ export class Call {
           !hasPending(this.joinLeaveConcurrencyTag)
         ) {
           this.leave().catch(() => {
-            this.logger(
-              'error',
+            this.logger.error(
               'Could not leave a call that was accepted or rejected elsewhere',
             );
           });
@@ -526,8 +524,7 @@ export class Call {
             break;
         }
       } catch (err) {
-        this.logger(
-          'error',
+        this.logger.error(
           `Can't disable mic/camera/screenshare after revoked permissions`,
           err,
         );
@@ -886,12 +883,12 @@ export class Call {
     maxJoinRetries = Math.max(maxJoinRetries, 1);
     for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
       try {
-        this.logger('trace', `Joining call (${attempt})`, this.cid);
+        this.logger.trace(`Joining call (${attempt})`, this.cid);
         await this.doJoin(data);
         delete joinData.migrating_from;
         break;
       } catch (err) {
-        this.logger('warn', `Failed to join call (${attempt})`, this.cid);
+        this.logger.warn(`Failed to join call (${attempt})`, this.cid);
         if (err instanceof ErrorFromResponse && err.unrecoverable) {
           // if the error is unrecoverable, we should not retry as that signals
           // that connectivity is good, but the coordinator doesn't allow the user
@@ -927,7 +924,7 @@ export class Call {
 
     this.joinCallData = data;
 
-    this.logger('debug', 'Starting join flow');
+    this.logger.debug('Starting join flow');
     this.state.setCallingState(CallingState.JOINING);
 
     const performingMigration =
@@ -1031,7 +1028,7 @@ export class Call {
           );
         }
       } catch (error) {
-        this.logger('warn', 'Join SFU request failed', error);
+        this.logger.warn('Join SFU request failed', error);
         sfuClient.close(
           StreamSfuClient.JOIN_FAILED,
           'Join request failed, connection considered unhealthy',
@@ -1103,7 +1100,7 @@ export class Call {
     this.reconnectStrategy = WebsocketReconnectStrategy.UNSPECIFIED;
     this.reconnectReason = '';
 
-    this.logger('info', `Joined call ${this.cid}`);
+    this.logger.info(`Joined call ${this.cid}`);
   };
 
   /**
@@ -1250,7 +1247,7 @@ export class Call {
       onReconnectionNeeded: (kind, reason) => {
         this.reconnect(kind, reason).catch((err) => {
           const message = `[Reconnect] Error reconnecting after a subscriber error: ${reason}`;
-          this.logger('warn', message, err);
+          this.logger.warn(message, err);
         });
       },
     });
@@ -1273,7 +1270,7 @@ export class Call {
         onReconnectionNeeded: (kind, reason) => {
           this.reconnect(kind, reason).catch((err) => {
             const message = `[Reconnect] Error reconnecting after a publisher error: ${reason}`;
-            this.logger('warn', message, err);
+            this.logger.warn(message, err);
           });
         },
       });
@@ -1358,7 +1355,7 @@ export class Call {
     sfuClient: StreamSfuClient,
     reason: string,
   ) => {
-    this.logger('debug', '[Reconnect] SFU signal connection closed');
+    this.logger.debug('[Reconnect] SFU signal connection closed');
     const { callingState } = this.state;
     if (
       // SFU WS closed before we finished current join,
@@ -1381,7 +1378,7 @@ export class Call {
         ? WebsocketReconnectStrategy.FAST
         : WebsocketReconnectStrategy.REJOIN;
     this.reconnect(strategy, reason).catch((err) => {
-      this.logger('warn', '[Reconnect] Error reconnecting', err);
+      this.logger.warn('[Reconnect] Error reconnecting', err);
     });
   };
 
@@ -1427,8 +1424,7 @@ export class Call {
           reconnectingTime / 1000 > this.disconnectionTimeoutSeconds;
 
         if (shouldGiveUpReconnecting) {
-          this.logger(
-            'warn',
+          this.logger.warn(
             '[Reconnect] Stopping reconnection attempts after reaching disconnection timeout',
           );
           await markAsReconnectingFailed();
@@ -1445,16 +1441,14 @@ export class Call {
           // wait until the network is available
           await this.networkAvailableTask?.promise;
 
-          this.logger(
-            'info',
+          this.logger.info(
             `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[this.reconnectStrategy]}`,
           );
 
           switch (this.reconnectStrategy) {
             case WebsocketReconnectStrategy.UNSPECIFIED:
             case WebsocketReconnectStrategy.DISCONNECT:
-              this.logger(
-                'debug',
+              this.logger.debug(
                 `[Reconnect] No-op strategy ${currentStrategy}`,
               );
               break;
@@ -1477,17 +1471,15 @@ export class Call {
           break; // do-while loop, reconnection worked, exit the loop
         } catch (error) {
           if (this.state.callingState === CallingState.OFFLINE) {
-            this.logger(
-              'debug',
+            this.logger.debug(
               `[Reconnect] Can't reconnect while offline, stopping reconnection attempts`,
             );
             break;
             // we don't need to handle the error if the call is offline
             // network change event will trigger the reconnection
           }
           if (error instanceof ErrorFromResponse && error.unrecoverable) {
-            this.logger(
-              'warn',
+            this.logger.warn(
               `[Reconnect] Can't reconnect due to coordinator unrecoverable error`,
               error,
             );
@@ -1520,8 +1512,7 @@ export class Call {
             : WebsocketReconnectStrategy.FAST;
           this.reconnectStrategy = nextStrategy;
 
-          this.logger(
-            'info',
+          this.logger.info(
             `[Reconnect] ${currentStrategy} (${this.reconnectAttempts}) failed. Attempting with ${WebsocketReconnectStrategy[nextStrategy]}`,
             error,
           );
@@ -1531,7 +1522,7 @@ export class Call {
         this.state.callingState !== CallingState.RECONNECTING_FAILED &&
         this.state.callingState !== CallingState.LEFT
       );
-      this.logger('info', '[Reconnect] Reconnection flow finished');
+      this.logger.info('[Reconnect] Reconnection flow finished');
     });
   };
 
@@ -1633,7 +1624,7 @@ export class Call {
     // handles the legacy "goAway" event
     const unregisterGoAway = this.on('goAway', () => {
       this.reconnect(WebsocketReconnectStrategy.MIGRATE, 'goAway').catch(
-        (err) => this.logger('warn', '[Reconnect] Error reconnecting', err),
+        (err) => this.logger.warn('[Reconnect] Error reconnecting', err),
       );
     });
 
@@ -1643,11 +1634,11 @@ export class Call {
       if (strategy === WebsocketReconnectStrategy.UNSPECIFIED) return;
       if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
         this.leave({ message: 'SFU instructed to disconnect' }).catch((err) => {
-          this.logger('warn', `Can't leave call after disconnect request`, err);
+          this.logger.warn(`Can't leave call after disconnect request`, err);
         });
       } else {
         this.reconnect(strategy, error?.message || 'SFU Error').catch((err) => {
-          this.logger('warn', '[Reconnect] Error reconnecting', err);
+          this.logger.warn('[Reconnect] Error reconnecting', err);
         });
       }
     });
@@ -1657,7 +1648,7 @@ export class Call {
       (e) => {
         this.tracer.trace('network.changed', e);
         if (!e.online) {
-          this.logger('debug', '[Reconnect] Going offline');
+          this.logger.debug('[Reconnect] Going offline');
           if (!this.hasJoinedOnce) return;
           this.lastOfflineTimestamp = Date.now();
           // create a new task that would resolve when the network is available
@@ -1674,8 +1665,7 @@ export class Call {
             }
 
             this.reconnect(strategy, 'Going online').catch((err) => {
-              this.logger(
-                'warn',
+              this.logger.warn(
                 '[Reconnect] Error reconnecting after going online',
                 err,
               );
@@ -1685,7 +1675,7 @@ export class Call {
           this.sfuStatsReporter?.stop();
           this.state.setCallingState(CallingState.OFFLINE);
         } else {
-          this.logger('debug', '[Reconnect] Going online');
+          this.logger.debug('[Reconnect] Going online');
           this.sfuClient?.close(
             StreamSfuClient.DISPOSE_OLD_SOCKET,
             'Closing WS to reconnect after going online',
@@ -1875,14 +1865,12 @@ export class Call {
    * @param options the options to use.
    */
   updatePublishOptions = (options: ClientPublishOptions) => {
-    this.logger(
-      'warn',
+    this.logger.warn(
       '[call.updatePublishOptions]: You are manually overriding the publish options for this call. ' +
         'This is not recommended, and it can cause call stability/compatibility issues. Use with caution.',
     );
     if (this.state.callingState === CallingState.JOINED) {
-      this.logger(
-        'warn',
+      this.logger.warn(
         'Updating publish options after joining the call does not have an effect',
       );
     }
@@ -1896,7 +1884,7 @@ export class Call {
    */
   notifyNoiseCancellationStarting = async () => {
     return this.sfuClient?.startNoiseCancellation().catch((err) => {
-      this.logger('warn', 'Failed to notify start of noise cancellation', err);
+      this.logger.warn('Failed to notify start of noise cancellation', err);
     });
   };
 
@@ -1907,7 +1895,7 @@ export class Call {
    */
   notifyNoiseCancellationStopped = async () => {
     return this.sfuClient?.stopNoiseCancellation().catch((err) => {
-      this.logger('warn', 'Failed to notify stop of noise cancellation', err);
+      this.logger.warn('Failed to notify stop of noise cancellation', err);
     });
   };
 
@@ -2489,7 +2477,7 @@ export class Call {
         reason: 'timeout',
         message: `ringing timeout - ${this.isCreatedByMe ? 'no one accepted' : `user didn't interact with incoming call screen`}`,
       }).catch((err) => {
-        this.logger('error', 'Failed to drop call', err);
+        this.logger.error('Failed to drop call', err);
       });
     }, timeoutInMs);
   };
@@ -2653,10 +2641,10 @@ export class Call {
     publish: boolean,
   ) => {
     await this.camera.apply(settings.video, publish).catch((err) => {
-      this.logger('warn', 'Camera init failed', err);
+      this.logger.warn('Camera init failed', err);
     });
     await this.microphone.apply(settings.audio, publish).catch((err) => {
-      this.logger('warn', 'Mic init failed', err);
+      this.logger.warn('Mic init failed', err);
     });
   };