@stream-io/video-client 1.35.0 → 1.36.0

package/dist/index.cjs.js

@@ -5,12 +5,32 @@ var runtime = require('@protobuf-ts/runtime');
 var runtimeRpc = require('@protobuf-ts/runtime-rpc');
 var axios = require('axios');
 var twirpTransport = require('@protobuf-ts/twirp-transport');
+var scopedLogger = require('@stream-io/logger');
 var rxjs = require('rxjs');
 var uaParserJs = require('ua-parser-js');
 var sdpTransform = require('sdp-transform');
 var workerTimer = require('@stream-io/worker-timer');
 var https = require('https');
 
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var scopedLogger__namespace = /*#__PURE__*/_interopNamespaceDefault(scopedLogger);
+
 /* tslint:disable */
 /**
  * @export
@@ -3727,7 +3747,7 @@ const withRequestLogger = (logger, level) => {
     return {
         interceptUnary: (next, method, input, options) => {
             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,
@@ -3863,16 +3883,6 @@ const isReactNative = () => {
     return navigator.product?.toLowerCase() === 'reactnative';
 };
 
-// log levels, sorted by verbosity
-const logLevels = Object.freeze({
-    trace: 0,
-    debug: 1,
-    info: 2,
-    warn: 3,
-    error: 4,
-});
-let logger;
-let level = 'info';
 const logToConsole = (logLevel, message, ...args) => {
     let logMethod;
     switch (logLevel) {
@@ -3904,26 +3914,7 @@ const logToConsole = (logLevel, message, ...args) => {
     }
     logMethod(message, ...args);
 };
-const setLogger = (l, lvl) => {
-    logger = l;
-    if (lvl) {
-        setLogLevel(lvl);
-    }
-};
-const setLogLevel = (l) => {
-    level = l;
-};
-const getLogLevel = () => level;
-const getLogger = (withTags) => {
-    const loggerMethod = logger || logToConsole;
-    const tags = (withTags || []).filter(Boolean).join(':');
-    const result = (logLevel, message, ...args) => {
-        if (logLevels[logLevel] >= logLevels[level]) {
-            loggerMethod(logLevel, `[${tags}]: ${message}`, ...args);
-        }
-    };
-    return result;
-};
+const videoLoggerSystem = scopedLogger__namespace.createLoggerSystem();
 
 /**
  * Creates a closure which wraps the given RPC call and retries invoking
@@ -3949,7 +3940,9 @@ const retryable = async (rpc, signal) => {
             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);
@@ -4020,14 +4013,14 @@ const isSfuEvent = (eventName) => {
 };
 class Dispatcher {
     constructor() {
-        this.logger = getLogger(['Dispatcher']);
+        this.logger = videoLoggerSystem.getLogger('Dispatcher');
         this.subscribers = {};
         this.dispatch = (message, tag = '0') => {
             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;
@@ -4036,7 +4029,7 @@ class Dispatcher {
                     fn(payload);
                 }
                 catch (e) {
-                    this.logger('warn', 'Listener failed with error', e);
+                    this.logger.warn('Listener failed with error', e);
                 }
             }
         };
@@ -4072,8 +4065,8 @@ class IceTrickleBuffer {
                 this.publisherCandidates.next(iceCandidate);
             }
             else {
-                const logger = getLogger(['sfu-client']);
-                logger('warn', `ICETrickle, Unknown peer type`, iceTrickle);
+                const logger = videoLoggerSystem.getLogger('sfu-client');
+                logger.warn(`ICETrickle, Unknown peer type`, iceTrickle);
             }
         };
         this.dispose = () => {
@@ -4087,8 +4080,8 @@ const toIceCandidate = (iceTrickle) => {
         return JSON.parse(iceTrickle.iceCandidate);
     }
     catch (e) {
-        const logger = getLogger(['sfu-client']);
-        logger('error', `Failed to parse ICE Trickle`, e, iceTrickle);
+        const logger = videoLoggerSystem.getLogger('sfu-client');
+        logger.error(`Failed to parse ICE Trickle`, e, iceTrickle);
         return undefined;
     }
 };
@@ -4264,7 +4257,9 @@ const updateValue = (subject, update) => {
  * @param handler the handler to call when the observable emits a value.
  * @param onError an optional error handler.
  */
-const createSubscription = (observable, handler, onError = (error) => getLogger(['RxUtils'])('warn', 'An observable emitted an error', error)) => {
+const createSubscription = (observable, handler, onError = (error) => videoLoggerSystem
+    .getLogger('RxUtils')
+    .warn('An observable emitted an error', error)) => {
     const subscription = observable.subscribe({ next: handler, error: onError });
     return () => {
         subscription.unsubscribe();
@@ -4384,8 +4379,8 @@ class StreamVideoWriteableStateStore {
          * @param call the call to remove
          */
         this.unregisterCall = (call) => {
-            const logger = getLogger(['client-state']);
-            logger('trace', `Unregistering call: ${call.cid}`);
+            const logger = videoLoggerSystem.getLogger('client-state');
+            logger.trace(`Unregistering call: ${call.cid}`);
             return this.setCalls((calls) => calls.filter((c) => c !== call));
         };
         /**
@@ -4400,15 +4395,15 @@ class StreamVideoWriteableStateStore {
         this.connectedUserSubject.subscribe(async (user) => {
             // leave all calls when the user disconnects.
             if (!user) {
-                const logger = getLogger(['client-state']);
+                const logger = videoLoggerSystem.getLogger('client-state');
                 for (const call of this.calls) {
                     if (call.state.callingState === exports.CallingState.LEFT)
                         continue;
-                    logger('info', `User disconnected, leaving call: ${call.cid}`);
+                    logger.info(`User disconnected, leaving call: ${call.cid}`);
                     await call
                         .leave({ message: 'client.disconnectUser() called' })
                         .catch((err) => {
-                        logger('error', `Error leaving call: ${call.cid}`, err);
+                        logger.error(`Error leaving call: ${call.cid}`, err);
                     });
                 }
             }
@@ -4802,7 +4797,7 @@ class CallState {
         // We keep these tracks around until we can associate them with a participant.
         this.orphanedTracks = [];
         this.callGrantsSubject = new rxjs.ReplaySubject(1);
-        this.logger = getLogger(['CallState']);
+        this.logger = videoLoggerSystem.getLogger('CallState');
         /**
          * A list of comparators that are used to sort the participants.
          */
@@ -4983,7 +4978,7 @@ class CallState {
         this.updateParticipant = (sessionId, patch) => {
             const participant = this.findParticipantBySessionId(sessionId);
             if (!participant) {
-                this.logger('warn', `Participant with sessionId ${sessionId} not found`);
+                this.logger.warn(`Participant with sessionId ${sessionId} not found`);
                 return;
             }
             const thePatch = typeof patch === 'function' ? patch(participant) : patch;
@@ -5862,7 +5857,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.35.0";
+const version = "1.36.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -6065,7 +6060,7 @@ var browsers = /*#__PURE__*/Object.freeze({
  * Creates a new StatsReporter instance that collects metrics about the ongoing call and reports them to the state store
  */
 const createStatsReporter = ({ subscriber, publisher, state, datacenter, pollingIntervalInMs = 2000, }) => {
-    const logger = getLogger(['stats']);
+    const logger = videoLoggerSystem.getLogger('stats');
     const getRawStatsForTrack = async (kind, selector) => {
         if (kind === 'subscriber' && subscriber) {
             return subscriber.getStats(selector);
@@ -6124,7 +6119,7 @@ const createStatsReporter = ({ subscriber, publisher, state, datacenter, polling
                     participantStats[sessionId] = await getStatsForStream(kind, tracks);
                 }
                 catch (e) {
-                    logger('warn', `Failed to collect ${kind} stats for ${userId}`, e);
+                    logger.warn(`Failed to collect ${kind} stats for ${userId}`, e);
                 }
             }
         }
@@ -6156,7 +6151,7 @@ const createStatsReporter = ({ subscriber, publisher, state, datacenter, polling
             // (they are expensive) if no one is listening to them
             if (state.isCallStatsReportObserved) {
                 await run().catch((e) => {
-                    logger('debug', 'Failed to collect stats', e);
+                    logger.debug('Failed to collect stats', e);
                 });
             }
             timeoutId = setTimeout(loop, pollingIntervalInMs);
@@ -6302,7 +6297,7 @@ const aggregate = (stats) => {
 
 class SfuStatsReporter {
     constructor(sfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, tracer, unifiedSessionId, }) {
-        this.logger = getLogger(['SfuStatsReporter']);
+        this.logger = videoLoggerSystem.getLogger('SfuStatsReporter');
         this.inputDevices = new Map();
         this.observeDevice = (device, kind) => {
             const { browserPermissionState$ } = device.state;
@@ -6353,7 +6348,7 @@ class SfuStatsReporter {
             // intentionally not awaiting the promise here
             // to avoid impeding with the ongoing actions.
             this.run(telemetryData).catch((err) => {
-                this.logger('warn', 'Failed to send telemetry data', err);
+                this.logger.warn('Failed to send telemetry data', err);
             });
         };
         this.run = async (telemetry) => {
@@ -6412,7 +6407,7 @@ class SfuStatsReporter {
             clearInterval(this.intervalId);
             this.intervalId = setInterval(() => {
                 this.run().catch((err) => {
-                    this.logger('warn', 'Failed to report stats', err);
+                    this.logger.warn('Failed to report stats', err);
                 });
             }, this.options.reporting_interval_ms);
         };
@@ -6429,14 +6424,14 @@ class SfuStatsReporter {
         };
         this.flush = () => {
             this.run().catch((err) => {
-                this.logger('warn', 'Failed to flush report stats', err);
+                this.logger.warn('Failed to flush report stats', err);
             });
         };
         this.scheduleOne = (timeout) => {
             clearTimeout(this.timeoutId);
             this.timeoutId = setTimeout(() => {
                 this.run().catch((err) => {
-                    this.logger('warn', 'Failed to report stats', err);
+                    this.logger.warn('Failed to report stats', err);
                 });
             }, timeout);
         };
@@ -6807,7 +6802,7 @@ class BasePeerConnection {
         this.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
                     ? WebsocketReconnectStrategy.FAST
@@ -6825,7 +6820,7 @@ class BasePeerConnection {
                 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);
                 });
             }));
         };
@@ -6842,7 +6837,7 @@ class BasePeerConnection {
                 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);
                 });
             });
         };
@@ -6886,7 +6881,7 @@ class BasePeerConnection {
         this.onIceCandidate = (e) => {
             const { candidate } = e;
             if (!candidate) {
-                this.logger('debug', 'null ice candidate');
+                this.logger.debug('null ice candidate');
                 return;
             }
             const iceCandidate = this.asJSON(candidate);
@@ -6895,7 +6890,7 @@ class BasePeerConnection {
                 .catch((err) => {
                 if (this.isDisposed)
                     return;
-                this.logger('warn', `ICETrickle failed`, err);
+                this.logger.warn(`ICETrickle failed`, err);
             });
         };
         /**
@@ -6916,7 +6911,7 @@ class BasePeerConnection {
          */
         this.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();
@@ -6938,7 +6933,7 @@ class BasePeerConnection {
          */
         this.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);
         };
         this.handleConnectionStateUpdate = (state) => {
@@ -6953,13 +6948,13 @@ 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;
@@ -6971,7 +6966,7 @@ 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;
                     }
@@ -6985,19 +6980,19 @@ class BasePeerConnection {
             const errorMessage = 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.
          */
         this.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.
          */
         this.onSignalingChange = () => {
-            this.logger('debug', `Signaling state changed`, this.pc.signalingState);
+            this.logger.debug(`Signaling state changed`, this.pc.signalingState);
         };
         this.peerType = peerType;
         this.sfuClient = sfuClient;
@@ -7005,10 +7000,7 @@ class BasePeerConnection {
         this.dispatcher = dispatcher;
         this.iceRestartDelay = iceRestartDelay;
         this.onReconnectionNeeded = onReconnectionNeeded;
-        this.logger = getLogger([
-            peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher',
-            tag,
-        ]);
+        this.logger = videoLoggerSystem.getLogger(peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher', { tags: [tag] });
         this.pc = this.createPeerConnection(connectionConfig);
         this.stats = new StatsTracer(this.pc, peerType, this.trackIdToTrackType);
         if (enableTracing) {
@@ -7131,7 +7123,7 @@ class TransceiverCache {
 }
 
 const ensureExhausted = (x, message) => {
-    getLogger(['helpers'])('warn', message, x);
+    videoLoggerSystem.getLogger('helpers').warn(message, x);
 };
 
 const trackTypeToParticipantStreamKey = (trackType) => {
@@ -7470,7 +7462,7 @@ class Publisher extends BasePeerConnection {
             params.degradationPreference = 'maintain-framerate';
             await transceiver.sender.setParameters(params);
             const trackType = publishOption.trackType;
-            this.logger('debug', `Added ${TrackType[trackType]} transceiver`);
+            this.logger.debug(`Added ${TrackType[trackType]} transceiver`);
             this.transceiverCache.add({ publishOption, transceiver, options });
             this.trackIdToTrackType.set(track.id, trackType);
             await this.negotiate();
@@ -7590,16 +7582,16 @@ class Publisher extends BasePeerConnection {
             const { trackType, layers, publishOptionId } = videoSender;
             const enabledLayers = layers.filter((l) => l.active);
             const tag = 'Update publish quality:';
-            this.logger('info', `${tag} requested layers by SFU:`, enabledLayers);
+            this.logger.info(`${tag} requested layers by SFU:`, enabledLayers);
             const transceiverId = this.transceiverCache.find((t) => t.publishOption.id === publishOptionId &&
                 t.publishOption.trackType === trackType);
             const sender = transceiverId?.transceiver.sender;
             if (!sender) {
-                return this.logger('warn', `${tag} no video sender found.`);
+                return this.logger.warn(`${tag} no video sender found.`);
             }
             const params = sender.getParameters();
             if (params.encodings.length === 0) {
-                return this.logger('warn', `${tag} there are no encodings set.`);
+                return this.logger.warn(`${tag} there are no encodings set.`);
             }
             const codecInUse = transceiverId?.publishOption.codec?.name;
             const usesSvcCodec = codecInUse && isSvcCodec(codecInUse);
@@ -7643,19 +7635,19 @@ class Publisher extends BasePeerConnection {
             }
             const activeEncoders = params.encodings.filter((e) => e.active);
             if (!changed) {
-                return this.logger('info', `${tag} no change:`, activeEncoders);
+                return this.logger.info(`${tag} no change:`, activeEncoders);
             }
             await sender.setParameters(params);
-            this.logger('info', `${tag} enabled rids:`, activeEncoders);
+            this.logger.info(`${tag} enabled rids:`, activeEncoders);
         };
         /**
          * Restarts the ICE connection and renegotiates with the SFU.
          */
         this.restartIce = async () => {
-            this.logger('debug', 'Restarting ICE connection');
+            this.logger.debug('Restarting ICE connection');
             const signalingState = this.pc.signalingState;
             if (this.isIceRestarting || signalingState === 'have-local-offer') {
-                this.logger('debug', 'ICE restart is already in progress');
+                this.logger.debug('ICE restart is already in progress');
                 return;
             }
             await this.negotiate({ iceRestart: true });
@@ -7817,13 +7809,13 @@ class Subscriber extends BasePeerConnection {
          * Restarts the ICE connection and renegotiates with the SFU.
          */
         this.restartIce = async () => {
-            this.logger('debug', 'Restarting ICE connection');
+            this.logger.debug('Restarting ICE connection');
             if (this.pc.signalingState === 'have-remote-offer') {
-                this.logger('debug', 'ICE restart is already in progress');
+                this.logger.debug('ICE restart is already in progress');
                 return;
             }
             if (this.pc.connectionState === 'new') {
-                this.logger('debug', `ICE connection is not yet established, skipping restart.`);
+                this.logger.debug(`ICE connection is not yet established, skipping restart.`);
                 return;
             }
             const previousIsIceRestarting = this.isIceRestarting;
@@ -7846,25 +7838,25 @@ class Subscriber extends BasePeerConnection {
             // example: `e3f6aaf8-b03d-4911-be36-83f47d37a76a:TRACK_TYPE_VIDEO`
             const [trackId, rawTrackType] = primaryStream.id.split(':');
             const participantToUpdate = this.state.participants.find((p) => p.trackLookupPrefix === trackId);
-            this.logger('debug', `[onTrack]: Got remote ${rawTrackType} track for userId: ${participantToUpdate?.userId}`, e.track.id, e.track);
+            this.logger.debug(`[onTrack]: Got remote ${rawTrackType} track for userId: ${participantToUpdate?.userId}`, e.track.id, e.track);
             const trackDebugInfo = `${participantToUpdate?.userId} ${rawTrackType}:${trackId}`;
             e.track.addEventListener('mute', () => {
-                this.logger('info', `[onTrack]: Track muted: ${trackDebugInfo}`);
+                this.logger.info(`[onTrack]: Track muted: ${trackDebugInfo}`);
             });
             e.track.addEventListener('unmute', () => {
-                this.logger('info', `[onTrack]: Track unmuted: ${trackDebugInfo}`);
+                this.logger.info(`[onTrack]: Track unmuted: ${trackDebugInfo}`);
             });
             e.track.addEventListener('ended', () => {
-                this.logger('info', `[onTrack]: Track ended: ${trackDebugInfo}`);
+                this.logger.info(`[onTrack]: Track ended: ${trackDebugInfo}`);
                 this.state.removeOrphanedTrack(primaryStream.id);
             });
             const trackType = toTrackType(rawTrackType);
             if (!trackType) {
-                return this.logger('error', `Unknown track type: ${rawTrackType}`);
+                return this.logger.error(`Unknown track type: ${rawTrackType}`);
             }
             this.trackIdToTrackType.set(e.track.id, trackType);
             if (!participantToUpdate) {
-                this.logger('warn', `[onTrack]: Received track for unknown participant: ${trackId}`, e);
+                this.logger.warn(`[onTrack]: Received track for unknown participant: ${trackId}`, e);
                 this.state.registerOrphanedTrack({
                     id: primaryStream.id,
                     trackLookupPrefix: trackId,
@@ -7875,7 +7867,7 @@ class Subscriber extends BasePeerConnection {
             }
             const streamKindProp = trackTypeToParticipantStreamKey(trackType);
             if (!streamKindProp) {
-                this.logger('error', `Unknown track type: ${rawTrackType}`);
+                this.logger.error(`Unknown track type: ${rawTrackType}`);
                 return;
             }
             // get the previous stream to dispose it later
@@ -7888,7 +7880,7 @@ class Subscriber extends BasePeerConnection {
             });
             // now, dispose the previous stream if it exists
             if (previousStream) {
-                this.logger('info', `[onTrack]: Cleaning up previous remote ${e.track.kind} tracks for userId: ${participantToUpdate.userId}`);
+                this.logger.info(`[onTrack]: Cleaning up previous remote ${e.track.kind} tracks for userId: ${participantToUpdate.userId}`);
                 previousStream.getTracks().forEach((t) => {
                     t.stop();
                     previousStream.removeTrack(t);
@@ -7915,7 +7907,7 @@ class Subscriber extends BasePeerConnection {
         this.pc.addEventListener('track', this.handleOnTrack);
         this.on('subscriberOffer', async (subscriberOffer) => {
             return this.negotiate(subscriberOffer).catch((err) => {
-                this.logger('error', `Negotiation failed.`, err);
+                this.logger.error(`Negotiation failed.`, err);
             });
         });
     }
@@ -7932,20 +7924,20 @@ class Subscriber extends BasePeerConnection {
 
 const createWebSocketSignalChannel = (opts) => {
     const { endpoint, onMessage, tag, tracer } = opts;
-    const logger = getLogger(['SfuClientWS', tag]);
-    logger('debug', 'Creating signaling WS channel:', endpoint);
+    const logger = videoLoggerSystem.getLogger('SfuClientWS', { tags: [tag] });
+    logger.debug('Creating signaling WS channel:', endpoint);
     const ws = new WebSocket(endpoint);
     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);
         tracer?.trace('signal.ws.error', e);
     });
     ws.addEventListener('close', (e) => {
-        logger('info', 'Signaling WS channel is closed', e);
+        logger.info('Signaling WS channel is closed', e);
         tracer?.trace('signal.ws.close', e);
     });
     ws.addEventListener('open', (e) => {
-        logger('info', 'Signaling WS channel is open', e);
+        logger.info('Signaling WS channel is open', e);
         tracer?.trace('signal.ws.open', e);
     });
     ws.addEventListener('message', (e) => {
@@ -7957,7 +7949,7 @@ const createWebSocketSignalChannel = (opts) => {
         }
         catch (err) {
             const message = 'Failed to decode a message. Check whether the Proto models match.';
-            logger('error', message, { event: e, error: err });
+            logger.error(message, { event: e, error: err });
             tracer?.trace('signal.ws.message.error', message);
         }
     });
@@ -8158,14 +8150,14 @@ class StreamSfuClient {
         this.close = (code = StreamSfuClient.NORMAL_CLOSURE, reason) => {
             this.isClosingClean = code !== StreamSfuClient.ERROR_CONNECTION_UNHEALTHY;
             if (this.signalWs.readyState === WebSocket.OPEN) {
-                this.logger('debug', `Closing SFU WS connection: ${code} - ${reason}`);
+                this.logger.debug(`Closing SFU WS connection: ${code} - ${reason}`);
                 this.signalWs.close(code, `js-client: ${reason}`);
                 this.signalWs.removeEventListener('close', this.handleWebSocketClose);
             }
             this.dispose();
         };
         this.dispose = () => {
-            this.logger('debug', 'Disposing SFU client');
+            this.logger.debug('Disposing SFU client');
             this.unsubscribeIceTrickle();
             this.unsubscribeNetworkChanged();
             clearInterval(this.keepAliveInterval);
@@ -8185,7 +8177,7 @@ class StreamSfuClient {
                 await this.notifyLeave(reason);
             }
             catch (err) {
-                this.logger('debug', 'Error notifying SFU about leaving call', err);
+                this.logger.debug('Error notifying SFU about leaving call', err);
             }
             this.close(StreamSfuClient.NORMAL_CLOSURE, reason.substring(0, 115));
         };
@@ -8306,10 +8298,10 @@ class StreamSfuClient {
             await this.signalReady(); // wait for the signal ws to be open
             const msgJson = SfuRequest.toJson(message);
             if (this.signalWs.readyState !== WebSocket.OPEN) {
-                this.logger('debug', 'Signal WS is not open. Skipping message', msgJson);
+                this.logger.debug('Signal WS is not open. Skipping message', msgJson);
                 return;
             }
-            this.logger('debug', `Sending message to: ${this.edgeName}`, msgJson);
+            this.logger.debug(`Sending message to: ${this.edgeName}`, msgJson);
             this.signalWs.send(SfuRequest.toBinary(message));
         };
         this.keepAlive = () => {
@@ -8317,7 +8309,7 @@ class StreamSfuClient {
             timers.clearInterval(this.keepAliveInterval);
             this.keepAliveInterval = timers.setInterval(() => {
                 this.ping().catch((e) => {
-                    this.logger('error', 'Error sending healthCheckRequest to SFU', e);
+                    this.logger.error('Error sending healthCheckRequest to SFU', e);
                 });
             }, this.pingIntervalInMs);
         };
@@ -8340,7 +8332,7 @@ class StreamSfuClient {
         this.edgeName = server.edge_name;
         this.joinResponseTimeout = joinResponseTimeout;
         this.tag = tag;
-        this.logger = getLogger(['SfuClient', tag]);
+        this.logger = videoLoggerSystem.getLogger('SfuClient', { tags: [tag] });
         this.tracer = enableTracing
             ? new Tracer(`${tag}-${this.edgeName}`)
             : undefined;
@@ -8349,7 +8341,8 @@ class StreamSfuClient {
             interceptors: [
                 withHeaders({ Authorization: `Bearer ${token}` }),
                 this.tracer && withRequestTracer(this.tracer.trace),
-                getLogLevel() === 'trace' && withRequestLogger(this.logger, 'trace'),
+                this.logger.getLogLevel() === 'trace' &&
+                    withRequestLogger(this.logger, 'trace'),
             ].filter((v) => !!v),
         });
         // Special handling for the ICETrickle kind of events.
@@ -8437,13 +8430,13 @@ const watchCallRejected = (call) => {
         const { call: eventCall } = event;
         const { session: callSession } = eventCall;
         if (!callSession) {
-            call.logger('warn', 'No call session provided. Ignoring call.rejected event.', event);
+            call.logger.warn('No call session provided. Ignoring call.rejected event.', event);
             return;
         }
         const rejectedBy = callSession.rejected_by;
         const { members, callingState } = call.state;
         if (callingState !== exports.CallingState.RINGING) {
-            call.logger('info', 'Call is not in ringing mode (it is either accepted or rejected already). Ignoring call.rejected event.', event);
+            call.logger.info('Call is not in ringing mode (it is either accepted or rejected already). Ignoring call.rejected event.', event);
             return;
         }
         if (call.isCreatedByMe) {
@@ -8451,7 +8444,7 @@ const watchCallRejected = (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',
@@ -8461,7 +8454,7 @@ const watchCallRejected = (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' });
             }
         }
@@ -8478,7 +8471,7 @@ const watchCallEnded = (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);
             });
         }
     };
@@ -8506,7 +8499,7 @@ const watchSfuCallEnded = (call) => {
             await call.leave({ message: `callEnded received: ${reason}` });
         }
         catch (err) {
-            call.logger('error', 'Failed to leave call after being ended by the SFU', err);
+            call.logger.error('Failed to leave call after being ended by the SFU', err);
         }
     });
 };
@@ -8589,7 +8582,7 @@ const watchLiveEnded = (dispatcher, 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);
             });
         }
     });
@@ -8601,9 +8594,9 @@ const watchSfuErrorReports = (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,
@@ -8657,7 +8650,7 @@ const handleRemoteSoftMute = (call) => {
         if (cause === TrackUnpublishReason.MODERATION &&
             sessionId === localParticipant?.sessionId) {
             const logger = call.logger;
-            logger('info', `Local participant's ${TrackType[type]} track is muted remotely`);
+            logger.info(`Local participant's ${TrackType[type]} track is muted remotely`);
             try {
                 if (type === TrackType.VIDEO) {
                     await call.camera.disable();
@@ -8670,11 +8663,11 @@ const handleRemoteSoftMute = (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);
             }
         }
     });
@@ -8995,7 +8988,7 @@ class DynascaleManager {
          * The viewport tracker instance.
          */
         this.viewportTracker = new ViewportTracker();
-        this.logger = getLogger(['DynascaleManager']);
+        this.logger = videoLoggerSystem.getLogger('DynascaleManager');
         this.pendingSubscriptionsUpdate = null;
         this.videoTrackSubscriptionOverridesSubject = new rxjs.BehaviorSubject({});
         this.videoTrackSubscriptionOverrides$ = this.videoTrackSubscriptionOverridesSubject.asObservable();
@@ -9052,7 +9045,7 @@ class DynascaleManager {
                 this.sfuClient
                     ?.updateSubscriptions(this.trackSubscriptions)
                     .catch((err) => {
-                    this.logger('debug', `Failed to update track subscriptions`, err);
+                    this.logger.debug(`Failed to update track subscriptions`, err);
                 });
             };
             if (debounceType) {
@@ -9141,7 +9134,7 @@ 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, {
@@ -9246,7 +9239,7 @@ 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,
@@ -9283,13 +9276,13 @@ class DynascaleManager {
                     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);
                     });
                 }
             };
@@ -9331,7 +9324,7 @@ 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);
                         });
                     }
                     const { selectedDevice } = this.speaker.state;
@@ -9383,7 +9376,7 @@ 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);
                 });
@@ -9620,7 +9613,7 @@ class BrowserPermission {
         this.disposeController = new AbortController();
         this.wasPrompted = false;
         this.listeners = new Set();
-        this.logger = getLogger(['permissions']);
+        this.logger = videoLoggerSystem.getLogger('permissions');
         const signal = this.disposeController.signal;
         this.ready = (async () => {
             const assumeGranted = () => {
@@ -9646,7 +9639,7 @@ class BrowserPermission {
                 }
             }
             catch (err) {
-                this.logger('debug', 'Failed to query permission status', err);
+                this.logger.debug('Failed to query permission status', err);
                 assumeGranted();
             }
         })();
@@ -9685,7 +9678,7 @@ class BrowserPermission {
                     typeof e === 'object' &&
                     'name' in e &&
                     (e.name === 'NotAllowedError' || e.name === 'SecurityError')) {
-                    this.logger('info', 'Browser permission was not granted', {
+                    this.logger.info('Browser permission was not granted', {
                         permission: this.permission,
                     });
                     this.setState('denied');
@@ -9694,7 +9687,7 @@ class BrowserPermission {
                     }
                     return false;
                 }
-                this.logger('error', `Failed to getUserMedia`, {
+                this.logger.error(`Failed to getUserMedia`, {
                     error: e,
                     permission: this.permission,
                 });
@@ -9915,10 +9908,12 @@ const getAudioStream = async (trackConstraints, tracer) => {
         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,
         });
@@ -9951,10 +9946,12 @@ const getVideoStream = async (trackConstraints, tracer) => {
         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,
         });
@@ -10003,7 +10000,9 @@ const getScreenShareStream = async (options, tracer) => {
     }
     catch (e) {
         tracer?.trace(`${tag}OnFailure`, e.name);
-        getLogger(['devices'])('error', 'Failed to get screen share stream', e);
+        videoLoggerSystem
+            .getLogger('devices')
+            .error('Failed to get screen share stream', e);
         throw e;
     }
 };
@@ -10065,7 +10064,7 @@ class DeviceManager {
         this.call = call;
         this.state = state;
         this.trackType = trackType;
-        this.logger = getLogger([`${TrackType[trackType].toLowerCase()} manager`]);
+        this.logger = videoLoggerSystem.getLogger(`${TrackType[trackType].toLowerCase()} manager`);
         this.setup();
     }
     setup() {
@@ -10228,6 +10227,7 @@ class DeviceManager {
         }
     }
     async applySettingsToStream() {
+        console.log('applySettingsToStream ');
         await withCancellation(this.statusChangeConcurrencyTag, async (signal) => {
             if (this.enabled) {
                 try {
@@ -10260,7 +10260,7 @@ class DeviceManager {
         const mediaStream = this.state.mediaStream;
         if (!mediaStream)
             return;
-        this.logger('debug', `${stopTracks ? 'Stopping' : 'Disabling'} stream`);
+        this.logger.debug(`${stopTracks ? 'Stopping' : 'Disabling'} stream`);
         if (this.call.state.callingState === exports.CallingState.JOINED) {
             await this.stopPublishStream();
         }
@@ -10306,7 +10306,7 @@ class DeviceManager {
         }
     }
     async unmuteStream() {
-        this.logger('debug', 'Starting stream');
+        this.logger.debug('Starting stream');
         let stream;
         let rootStream;
         if (this.state.mediaStream &&
@@ -10387,7 +10387,7 @@ class DeviceManager {
                 return output;
             })
                 .then(chainWith(parent), (error) => {
-                this.logger('warn', 'Filter failed to start and will be ignored', error);
+                this.logger.warn('Filter failed to start and will be ignored', error);
                 return parent;
             }), rootStream);
         }
@@ -10410,7 +10410,7 @@ class DeviceManager {
                 if (!isMobile() || this.trackType !== TrackType.VIDEO)
                     return;
                 this.call.notifyTrackMuteState(muted, this.trackType).catch((err) => {
-                    this.logger('warn', 'Error while notifying track mute state', err);
+                    this.logger.warn('Error while notifying track mute state', err);
                 });
             };
             stream.getTracks().forEach((track) => {
@@ -10474,7 +10474,7 @@ class DeviceManager {
                 }
             }
             catch (err) {
-                this.logger('warn', 'Unexpected error while handling disconnected or replaced device', err);
+                this.logger.warn('Unexpected error while handling disconnected or replaced device', err);
             }
         }));
     }
@@ -10681,7 +10681,7 @@ class CameraManager extends DeviceManager {
      */
     async selectDirection(direction) {
         if (!this.isDirectionSupportedByDevice()) {
-            this.logger('warn', 'Setting direction is not supported on this device');
+            this.logger.warn('Setting direction is not supported on this device');
             return;
         }
         if (isReactNative()) {
@@ -10732,7 +10732,7 @@ class CameraManager extends DeviceManager {
             }
             catch (error) {
                 // couldn't enable device, target resolution will be applied the next time user attempts to start the device
-                this.logger('warn', 'could not apply target resolution', error);
+                this.logger.warn('could not apply target resolution', error);
             }
         }
         if (this.enabled && this.state.mediaStream) {
@@ -10743,7 +10743,7 @@ class CameraManager extends DeviceManager {
             if (width !== this.targetResolution.width ||
                 height !== this.targetResolution.height) {
                 await this.applySettingsToStream();
-                this.logger('debug', `${width}x${height} target resolution applied to media stream`);
+                this.logger.debug(`${width}x${height} target resolution applied to media stream`);
             }
         }
     }
@@ -11007,8 +11007,8 @@ class RNSpeechDetector {
             };
         }
         catch (error) {
-            const logger = getLogger(['RNSpeechDetector']);
-            logger('error', 'error handling permissions: ', error);
+            const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
+            logger.error('error handling permissions: ', error);
             return () => { };
         }
     }
@@ -11092,8 +11092,8 @@ 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);
             }
         };
         // Call checkAudioLevel periodically (every 100ms)
@@ -11153,7 +11153,7 @@ class MicrophoneManager extends AudioDeviceManager {
                 }
             }
             catch (err) {
-                this.logger('warn', 'Could not enable speaking while muted', err);
+                this.logger.warn('Could not enable speaking while muted', err);
             }
         }));
         this.subscriptions.push(createSubscription(this.call.state.callingState$, (callingState) => {
@@ -11176,7 +11176,7 @@ class MicrophoneManager extends AudioDeviceManager {
                     }
                 })
                     .catch((err) => {
-                    this.logger('warn', `Failed to enable noise cancellation`, err);
+                    this.logger.warn(`Failed to enable noise cancellation`, err);
                     return this.call.notifyNoiseCancellationStopped();
                 });
             }
@@ -11184,7 +11184,7 @@ class MicrophoneManager extends AudioDeviceManager {
                 this.noiseCancellationRegistration
                     .then(() => this.noiseCancellation?.disable())
                     .catch((err) => {
-                    this.logger('warn', `Failed to disable noise cancellation`, err);
+                    this.logger.warn(`Failed to disable noise cancellation`, err);
                 });
             }
         }));
@@ -11213,12 +11213,12 @@ class MicrophoneManager extends AudioDeviceManager {
                 this.call.tracer.trace('noiseCancellation.enabled', enabled);
                 if (enabled) {
                     this.call.notifyNoiseCancellationStarting().catch((err) => {
-                        this.logger('warn', `notifyNoiseCancellationStart failed`, err);
+                        this.logger.warn(`notifyNoiseCancellationStart failed`, err);
                     });
                 }
                 else {
                     this.call.notifyNoiseCancellationStopped().catch((err) => {
-                        this.logger('warn', `notifyNoiseCancellationStop failed`, err);
+                        this.logger.warn(`notifyNoiseCancellationStop failed`, err);
                     });
                 }
             });
@@ -11247,9 +11247,9 @@ class MicrophoneManager extends AudioDeviceManager {
             }
         }
         catch (e) {
-            this.logger('warn', 'Failed to enable noise cancellation', e);
+            this.logger.warn('Failed to enable noise cancellation', e);
             await this.disableNoiseCancellation().catch((err) => {
-                this.logger('warn', 'Failed to disable noise cancellation', err);
+                this.logger.warn('Failed to disable noise cancellation', err);
             });
             throw e;
         }
@@ -11262,7 +11262,7 @@ class MicrophoneManager extends AudioDeviceManager {
             .then(() => this.noiseCancellation?.disable())
             .then(() => this.noiseCancellationChangeUnsubscribe?.())
             .catch((err) => {
-            this.logger('warn', 'Failed to unregister noise cancellation', err);
+            this.logger.warn('Failed to unregister noise cancellation', err);
         });
         this.call.tracer.trace('noiseCancellation.disabled', true);
         await this.call.notifyNoiseCancellationStopped();
@@ -11770,9 +11770,9 @@ class Call {
                     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);
                     });
                 }
             }));
@@ -11808,7 +11808,7 @@ class Call {
                 if ((isAcceptedElsewhere || isRejectedByMe) &&
                     !hasPending(this.joinLeaveConcurrencyTag)) {
                     this.leave().catch(() => {
-                        this.logger('error', 'Could not leave a call that was accepted or rejected elsewhere');
+                        this.logger.error('Could not leave a call that was accepted or rejected elsewhere');
                     });
                 }
             }));
@@ -11888,7 +11888,7 @@ class Call {
                     }
                 }
                 catch (err) {
-                    this.logger('error', `Can't disable mic/camera/screenshare after revoked permissions`, err);
+                    this.logger.error(`Can't disable mic/camera/screenshare after revoked permissions`, err);
                 }
             }
         };
@@ -12149,13 +12149,13 @@ 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
@@ -12185,7 +12185,7 @@ class Call {
             const connectStartTime = Date.now();
             const callingState = this.state.callingState;
             this.joinCallData = data;
-            this.logger('debug', 'Starting join flow');
+            this.logger.debug('Starting join flow');
             this.state.setCallingState(exports.CallingState.JOINING);
             const performingMigration = this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE;
             const performingRejoin = this.reconnectStrategy === WebsocketReconnectStrategy.REJOIN;
@@ -12270,7 +12270,7 @@ 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');
                     // restore the previous call state if the join-flow fails
                     this.state.setCallingState(callingState);
@@ -12327,7 +12327,7 @@ class Call {
             // reset the reconnect strategy to unspecified after a successful reconnection
             this.reconnectStrategy = WebsocketReconnectStrategy.UNSPECIFIED;
             this.reconnectReason = '';
-            this.logger('info', `Joined call ${this.cid}`);
+            this.logger.info(`Joined call ${this.cid}`);
         };
         /**
          * Prepares Reconnect Details object.
@@ -12440,7 +12440,7 @@ 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);
                     });
                 },
             });
@@ -12462,7 +12462,7 @@ 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);
                         });
                     },
                 });
@@ -12531,7 +12531,7 @@ class Call {
          * @param reason the reason for the closure.
          */
         this.handleSfuSignalClose = (sfuClient, reason) => {
-            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,
@@ -12552,7 +12552,7 @@ 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);
             });
         };
         /**
@@ -12588,7 +12588,7 @@ class Call {
                     const shouldGiveUpReconnecting = this.disconnectionTimeoutSeconds > 0 &&
                         reconnectingTime / 1000 > this.disconnectionTimeoutSeconds;
                     if (shouldGiveUpReconnecting) {
-                        this.logger('warn', '[Reconnect] Stopping reconnection attempts after reaching disconnection timeout');
+                        this.logger.warn('[Reconnect] Stopping reconnection attempts after reaching disconnection timeout');
                         await markAsReconnectingFailed();
                         return;
                     }
@@ -12600,11 +12600,11 @@ class Call {
                     try {
                         // wait until the network is available
                         await this.networkAvailableTask?.promise;
-                        this.logger('info', `[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[this.reconnectStrategy]}`);
+                        this.logger.info(`[Reconnect] Reconnecting with strategy ${WebsocketReconnectStrategy[this.reconnectStrategy]}`);
                         switch (this.reconnectStrategy) {
                             case WebsocketReconnectStrategy.UNSPECIFIED:
                             case WebsocketReconnectStrategy.DISCONNECT:
-                                this.logger('debug', `[Reconnect] No-op strategy ${currentStrategy}`);
+                                this.logger.debug(`[Reconnect] No-op strategy ${currentStrategy}`);
                                 break;
                             case WebsocketReconnectStrategy.FAST:
                                 await this.reconnectFast();
@@ -12623,13 +12623,13 @@ class Call {
                     }
                     catch (error) {
                         if (this.state.callingState === exports.CallingState.OFFLINE) {
-                            this.logger('debug', `[Reconnect] Can't reconnect while offline, stopping reconnection attempts`);
+                            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', `[Reconnect] Can't reconnect due to coordinator unrecoverable error`, error);
+                            this.logger.warn(`[Reconnect] Can't reconnect due to coordinator unrecoverable error`, error);
                             await markAsReconnectingFailed();
                             return;
                         }
@@ -12650,12 +12650,12 @@ class Call {
                             ? WebsocketReconnectStrategy.REJOIN
                             : WebsocketReconnectStrategy.FAST;
                         this.reconnectStrategy = nextStrategy;
-                        this.logger('info', `[Reconnect] ${currentStrategy} (${this.reconnectAttempts}) failed. Attempting with ${WebsocketReconnectStrategy[nextStrategy]}`, error);
+                        this.logger.info(`[Reconnect] ${currentStrategy} (${this.reconnectAttempts}) failed. Attempting with ${WebsocketReconnectStrategy[nextStrategy]}`, error);
                     }
                 } while (this.state.callingState !== exports.CallingState.JOINED &&
                     this.state.callingState !== exports.CallingState.RECONNECTING_FAILED &&
                     this.state.callingState !== exports.CallingState.LEFT);
-                this.logger('info', '[Reconnect] Reconnection flow finished');
+                this.logger.info('[Reconnect] Reconnection flow finished');
             });
         };
         /**
@@ -12737,7 +12737,7 @@ class Call {
         this.registerReconnectHandlers = () => {
             // handles the legacy "goAway" event
             const unregisterGoAway = this.on('goAway', () => {
-                this.reconnect(WebsocketReconnectStrategy.MIGRATE, 'goAway').catch((err) => this.logger('warn', '[Reconnect] Error reconnecting', err));
+                this.reconnect(WebsocketReconnectStrategy.MIGRATE, 'goAway').catch((err) => this.logger.warn('[Reconnect] Error reconnecting', err));
             });
             // handles the "error" event, through which the SFU can request a reconnect
             const unregisterOnError = this.on('error', (e) => {
@@ -12746,19 +12746,19 @@ class Call {
                     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);
                     });
                 }
             });
             const unregisterNetworkChanged = this.streamClient.on('network.changed', (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();
@@ -12775,7 +12775,7 @@ class Call {
                             }
                         }
                         this.reconnect(strategy, 'Going online').catch((err) => {
-                            this.logger('warn', '[Reconnect] Error reconnecting after going online', err);
+                            this.logger.warn('[Reconnect] Error reconnecting after going online', err);
                         });
                     });
                     this.networkAvailableTask = networkAvailableTask;
@@ -12783,7 +12783,7 @@ class Call {
                     this.state.setCallingState(exports.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');
                     // we went online, release the previous waiters and reset the state
                     this.networkAvailableTask?.resolve();
@@ -12945,10 +12945,10 @@ class Call {
          * @param options the options to use.
          */
         this.updatePublishOptions = (options) => {
-            this.logger('warn', '[call.updatePublishOptions]: You are manually overriding the publish options for this call. ' +
+            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 === exports.CallingState.JOINED) {
-                this.logger('warn', 'Updating publish options after joining the call does not have an effect');
+                this.logger.warn('Updating publish options after joining the call does not have an effect');
             }
             this.clientPublishOptions = { ...this.clientPublishOptions, ...options };
         };
@@ -12959,7 +12959,7 @@ class Call {
          */
         this.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);
             });
         };
         /**
@@ -12969,7 +12969,7 @@ class Call {
          */
         this.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);
             });
         };
         /**
@@ -13403,7 +13403,7 @@ 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);
         };
@@ -13515,10 +13515,10 @@ class Call {
          */
         this.applyDeviceConfig = async (settings, publish) => {
             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);
             });
         };
         /**
@@ -13670,7 +13670,7 @@ 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 = sortParticipantsBy || callTypeConfig.options.sortParticipantsBy;
         if (participantSorter) {
@@ -13757,7 +13757,7 @@ const APIErrorCodes = {
 class StableWSConnection {
     constructor(client) {
         this._log = (msg, extra = {}, level = 'info') => {
-            this.client.logger(level, `connection:${msg}`, extra);
+            this.client.logger[level](`connection:${msg}`, extra);
         };
         this.setClient = (client) => {
             this.client = client;
@@ -13803,12 +13803,12 @@ class StableWSConnection {
                 return;
             const user = this.client.user;
             if (!user) {
-                this.client.logger('error', `User not set, can't connect to WS`);
+                this.client.logger.error(`User not set, can't connect to WS`);
                 return;
             }
             const token = this.client._getToken();
             if (!token) {
-                this.client.logger('error', `Token not set, can't connect authenticate`);
+                this.client.logger.error(`Token not set, can't connect authenticate`);
                 return;
             }
             const authMessage = JSON.stringify({
@@ -14445,7 +14445,7 @@ class TokenManager {
 }
 
 const getLocationHint = async (hintUrl = `https://hint.stream-io-video.com/`, timeout = 2000, maxAttempts = 3) => {
-    const logger = getLogger(['location-hint']);
+    const logger = videoLoggerSystem.getLogger('location-hint');
     let attempt = 0;
     let locationHint = 'ERR';
     do {
@@ -14457,11 +14457,11 @@ const getLocationHint = async (hintUrl = `https://hint.stream-io-video.com/`, ti
                 signal: abortController.signal,
             });
             const awsPop = response.headers.get('x-amz-cf-pop') || 'ERR';
-            logger('debug', `Location header: ${awsPop}`);
+            logger.debug(`Location header: ${awsPop}`);
             locationHint = awsPop.substring(0, 3); // AMS1-P2 -> AMS
         }
         catch (e) {
-            logger('warn', `Failed to get location hint from ${hintUrl}`, e);
+            logger.warn(`Failed to get location hint from ${hintUrl}`, e);
             locationHint = 'ERR';
         }
         finally {
@@ -14522,14 +14522,14 @@ class StreamClient {
              * If the user id remains the same we don't throw error
              */
             if (this.userID === user.id && this.connectUserTask) {
-                this.logger('warn', 'Consecutive calls to connectUser is detected, ideally you should only call this function once in your app.');
+                this.logger.warn('Consecutive calls to connectUser is detected, ideally you should only call this function once in your app.');
                 return this.connectUserTask;
             }
             if (this.userID) {
                 throw new Error('Use client.disconnect() before trying to connect as a different user. connectUser was called twice.');
             }
             if ((this.secret || this.node) && !this.options.allowServerSideConnect) {
-                this.logger('warn', 'Please do not use connectUser server side. Use our @stream-io/node-sdk instead: https://getstream.io/video/docs/api/');
+                this.logger.warn('Please do not use connectUser server side. Use our @stream-io/node-sdk instead: https://getstream.io/video/docs/api/');
             }
             // we generate the client id client side
             this.userID = user.id;
@@ -14587,11 +14587,11 @@ class StreamClient {
             }
             const wsPromise = this.wsPromiseSafe?.();
             if (this.wsConnection?.isConnecting && wsPromise) {
-                this.logger('info', 'client:openConnection() - connection already in progress');
+                this.logger.info('client:openConnection() - connection already in progress');
                 return await wsPromise;
             }
             if (this.wsConnection?.isHealthy && this._hasConnectionID()) {
-                this.logger('info', 'client:openConnection() - openConnection called twice, healthy connection already exists');
+                this.logger.info('client:openConnection() - openConnection called twice, healthy connection already exists');
                 return;
             }
             this._setupConnectionIdPromise();
@@ -14607,7 +14607,7 @@ class StreamClient {
          *                https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
          */
         this.disconnectUser = async (timeout) => {
-            this.logger('info', 'client:disconnect() - Disconnecting the client');
+            this.logger.info('client:disconnect() - Disconnecting the client');
             // remove the user specific fields
             delete this.user;
             delete this._user;
@@ -14654,7 +14654,7 @@ class StreamClient {
             if (!this.listeners[eventName]) {
                 this.listeners[eventName] = [];
             }
-            this.logger('debug', `Adding listener for ${eventName} event`);
+            this.logger.debug(`Adding listener for ${eventName} event`);
             this.listeners[eventName]?.push(callback);
             return () => {
                 this.off(eventName, callback);
@@ -14667,7 +14667,7 @@ class StreamClient {
             if (!this.listeners[eventName]) {
                 this.listeners[eventName] = [];
             }
-            this.logger('debug', `Removing listener for ${eventName} event`);
+            this.logger.debug(`Removing listener for ${eventName} event`);
             this.listeners[eventName] = this.listeners[eventName]?.filter((value) => value !== callback);
         };
         /**
@@ -14681,17 +14681,17 @@ class StreamClient {
             }));
         };
         this._logApiRequest = (type, url, data, config) => {
-            if (getLogLevel() !== 'trace')
+            if (this.logger.getLogLevel() !== 'trace')
                 return;
-            this.logger('trace', `client: ${type} - Request - ${url}`, {
+            this.logger.trace(`client: ${type} - Request - ${url}`, {
                 payload: data,
                 config,
             });
         };
         this._logApiResponse = (type, url, response) => {
-            if (getLogLevel() !== 'trace')
+            if (this.logger.getLogLevel() !== 'trace')
                 return;
-            this.logger('trace', `client:${type} - Response - url: ${url} > status ${response.status}`, {
+            this.logger.trace(`client:${type} - Response - url: ${url} > status ${response.status}`, {
                 response,
             });
         };
@@ -14748,13 +14748,13 @@ class StreamClient {
                 this.consecutiveFailures += 1;
                 const { response } = e;
                 if (!response || !isErrorResponse(response)) {
-                    this.logger('error', `client:${type} url: ${url}`, e);
+                    this.logger.error(`client:${type} url: ${url}`, e);
                     throw e;
                 }
                 const { data: responseData, status } = response;
                 const isTokenExpired = responseData.code === KnownCodes.TOKEN_EXPIRED;
                 if (isTokenExpired && !this.tokenManager.isStatic()) {
-                    this.logger('warn', `client:${type}: url: ${url}`, response);
+                    this.logger.warn(`client:${type}: url: ${url}`, response);
                     if (this.consecutiveFailures > 1) {
                         await sleep(retryInterval(this.consecutiveFailures));
                     }
@@ -14763,7 +14763,7 @@ class StreamClient {
                     return await this.doAxiosRequest(type, url, data, options);
                 }
                 else {
-                    this.logger('error', `client:${type} url: ${url}`, response);
+                    this.logger.error(`client:${type} url: ${url}`, response);
                     throw new ErrorFromResponse({
                         message: `Stream error code ${responseData.code}: ${responseData.message}`,
                         code: responseData.code ?? null,
@@ -14794,7 +14794,7 @@ class StreamClient {
             });
         };
         this.dispatchEvent = (event) => {
-            this.logger('debug', `Dispatching event: ${event.type}`, event);
+            this.logger.debug(`Dispatching event: ${event.type}`, event);
             if (!this.listeners)
                 return;
             // call generic listeners
@@ -14819,13 +14819,13 @@ class StreamClient {
                 throw Error('clientID is not set');
             // The StableWSConnection handles all the reconnection logic.
             this.wsConnection = new StableWSConnection(this);
-            this.logger('info', 'StreamClient.connect: this.wsConnection.connect()');
+            this.logger.info('StreamClient.connect: this.wsConnection.connect()');
             return await this.wsConnection.connect(this.defaultWSTimeout);
         };
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.35.0", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.36.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -14876,11 +14876,11 @@ class StreamClient {
         };
         this.updateNetworkConnectionStatus = (event) => {
             if (event.type === 'offline') {
-                this.logger('debug', 'device went offline');
+                this.logger.debug('device went offline');
                 this.dispatchEvent({ type: 'network.changed', online: false });
             }
             else if (event.type === 'online') {
-                this.logger('debug', 'device went online');
+                this.logger.debug('device went online');
                 this.dispatchEvent({ type: 'network.changed', online: true });
             }
         };
@@ -14928,9 +14928,7 @@ class StreamClient {
         this.tokenManager = new TokenManager(this.secret);
         this.consecutiveFailures = 0;
         this.defaultWSTimeout = this.options.defaultWsTimeout ?? 15000;
-        this.logger = isFunction(inputOptions.logger)
-            ? inputOptions.logger
-            : () => null;
+        this.logger = videoLoggerSystem.getLogger('coordinator');
     }
     get connectionIdPromise() {
         return this.connectionIdPromiseSafe?.();
@@ -14975,12 +14973,10 @@ const getClientAppIdentifier = (options) => {
  */
 const createCoordinatorClient = (apiKey, options) => {
     const clientAppIdentifier = getClientAppIdentifier(options);
-    const coordinatorLogger = getLogger(['coordinator']);
     return new StreamClient(apiKey, {
         persistUserOnConnectionFailure: true,
         ...options,
         clientAppIdentifier,
-        logger: coordinatorLogger,
     });
 };
 /**
@@ -15018,7 +15014,7 @@ class StreamVideoClient {
         this.registerClientInstance = (apiKey, user) => {
             const instanceKey = getInstanceKey(apiKey, user);
             if (StreamVideoClient._instances.has(instanceKey)) {
-                this.logger('warn', `A StreamVideoClient already exists for ${user.id}; Prefer using getOrCreateInstance method`);
+                this.logger.warn(`A StreamVideoClient already exists for ${user.id}; Prefer using getOrCreateInstance method`);
             }
             StreamVideoClient._instances.set(instanceKey, this);
         };
@@ -15033,13 +15029,13 @@ class StreamVideoClient {
                     .map((call) => call.cid);
                 if (callsToReWatch.length <= 0)
                     return;
-                this.logger('info', `Rewatching calls ${callsToReWatch.join(', ')}`);
+                this.logger.info(`Rewatching calls ${callsToReWatch.join(', ')}`);
                 this.queryCalls({
                     watch: true,
                     filter_conditions: { cid: { $in: callsToReWatch } },
                     sort: [{ field: 'cid', direction: 1 }],
                 }).catch((err) => {
-                    this.logger('error', 'Failed to re-watch calls', err);
+                    this.logger.error('Failed to re-watch calls', err);
                 });
             }));
             this.effectsRegistered = true;
@@ -15050,7 +15046,7 @@ class StreamVideoClient {
          */
         this.initCallFromEvent = async (e) => {
             if (this.state.connectedUser?.id === e.call.created_by.id) {
-                this.logger('debug', `Ignoring ${e.type} event sent by the current user`);
+                this.logger.debug(`Ignoring ${e.type} event sent by the current user`);
                 return;
             }
             try {
@@ -15061,7 +15057,7 @@ class StreamVideoClient {
                     if (call) {
                         if (ringing) {
                             if (this.shouldRejectCall(call.cid)) {
-                                this.logger('info', `Leaving call with busy reject reason ${call.cid} because user is busy`);
+                                this.logger.info(`Leaving call with busy reject reason ${call.cid} because user is busy`);
                                 // remove the instance from the state store
                                 await call.leave();
                                 // explicitly reject the call with busy reason as calling state was not ringing before and leave would not call it therefore
@@ -15086,7 +15082,7 @@ class StreamVideoClient {
                     });
                     if (ringing) {
                         if (this.shouldRejectCall(call.cid)) {
-                            this.logger('info', `Rejecting call ${call.cid} because user is busy`);
+                            this.logger.info(`Rejecting call ${call.cid} because user is busy`);
                             // call is not in the state store yet, so just reject api is enough
                             await call.reject('busy');
                         }
@@ -15098,12 +15094,12 @@ class StreamVideoClient {
                     else {
                         call.state.updateFromCallResponse(e.call);
                         this.writeableStateStore.registerCall(call);
-                        this.logger('info', `New call created and registered: ${call.cid}`);
+                        this.logger.info(`New call created and registered: ${call.cid}`);
                     }
                 });
             }
             catch (err) {
-                this.logger('error', `Failed to init call from event ${e.type}`, err);
+                this.logger.error(`Failed to init call from event ${e.type}`, err);
             }
         };
         /**
@@ -15127,13 +15123,13 @@ class StreamVideoClient {
                 const errorQueue = [];
                 for (let attempt = 0; attempt < maxConnectUserRetries; attempt++) {
                     try {
-                        this.logger('trace', `Connecting user (${attempt})`, user);
+                        this.logger.trace(`Connecting user (${attempt})`, user);
                         return user.type === 'guest'
                             ? await client.connectGuestUser(user)
                             : await client.connectUser(user, tokenOrProvider);
                     }
                     catch (err) {
-                        this.logger('warn', `Failed to connect a user (${attempt})`, err);
+                        this.logger.warn(`Failed to connect a user (${attempt})`, err);
                         errorQueue.push(err);
                         if (attempt === maxConnectUserRetries - 1) {
                             onConnectUserError?.(err, errorQueue);
@@ -15378,8 +15374,11 @@ class StreamVideoClient {
         if (clientOptions?.enableTimerWorker)
             enableTimerWorker();
         const rootLogger = clientOptions?.logger || logToConsole;
-        setLogger(rootLogger, clientOptions?.logLevel || 'warn');
-        this.logger = getLogger(['client']);
+        videoLoggerSystem.configureLoggers({
+            default: { sink: rootLogger, level: clientOptions?.logLevel || 'warn' },
+            ...clientOptions?.logOptions,
+        });
+        this.logger = videoLoggerSystem.getLogger('client');
         this.rejectCallWhenBusy = clientOptions?.rejectCallWhenBusy ?? false;
         this.streamClient = createCoordinatorClient(apiKey, clientOptions);
         this.writeableStateStore = new StreamVideoWriteableStateStore();
@@ -15392,7 +15391,7 @@ class StreamVideoClient {
                 this.registerClientInstance(apiKey, user);
             const tokenOrProvider = createTokenOrProvider(apiKeyOrArgs);
             this.connectUser(user, tokenOrProvider).catch((err) => {
-                this.logger('error', 'Failed to connect', err);
+                this.logger.error('Failed to connect', err);
             });
         }
     }
@@ -15426,6 +15425,10 @@ Object.defineProperty(exports, "AxiosError", {
     enumerable: true,
     get: function () { return axios.AxiosError; }
 });
+Object.defineProperty(exports, "LogLevelEnum", {
+    enumerable: true,
+    get: function () { return scopedLogger.LogLevelEnum; }
+});
 exports.AudioSettingsRequestDefaultDeviceEnum = AudioSettingsRequestDefaultDeviceEnum;
 exports.AudioSettingsResponseDefaultDeviceEnum = AudioSettingsResponseDefaultDeviceEnum;
 exports.Browsers = browsers;
@@ -15493,8 +15496,6 @@ exports.getAudioOutputDevices = getAudioOutputDevices;
 exports.getAudioStream = getAudioStream;
 exports.getClientDetails = getClientDetails;
 exports.getDeviceState = getDeviceState;
-exports.getLogLevel = getLogLevel;
-exports.getLogger = getLogger;
 exports.getScreenShareStream = getScreenShareStream;
 exports.getSdkInfo = getSdkInfo;
 exports.getVideoBrowserPermission = getVideoBrowserPermission;
@@ -15508,7 +15509,6 @@ exports.hasScreenShareAudio = hasScreenShareAudio;
 exports.hasVideo = hasVideo;
 exports.isPinned = isPinned;
 exports.livestreamOrAudioRoomSortPreset = livestreamOrAudioRoomSortPreset;
-exports.logLevels = logLevels;
 exports.logToConsole = logToConsole;
 exports.name = name;
 exports.noopComparator = noopComparator;
@@ -15521,8 +15521,6 @@ exports.resolveDeviceId = resolveDeviceId;
 exports.role = role;
 exports.screenSharing = screenSharing;
 exports.setDeviceInfo = setDeviceInfo;
-exports.setLogLevel = setLogLevel;
-exports.setLogger = setLogger;
 exports.setOSInfo = setOSInfo;
 exports.setPowerState = setPowerState;
 exports.setSdkInfo = setSdkInfo;
@@ -15530,5 +15528,6 @@ exports.setThermalState = setThermalState;
 exports.setWebRTCInfo = setWebRTCInfo;
 exports.speakerLayoutSortPreset = speakerLayoutSortPreset;
 exports.speaking = speaking;
+exports.videoLoggerSystem = videoLoggerSystem;
 exports.withParticipantSource = withParticipantSource;
 //# sourceMappingURL=index.cjs.js.map