@stream-io/video-client 1.27.1 → 1.27.3

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [1.27.3](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.27.2...@stream-io/video-client-1.27.3) (2025-08-07)
+
+### Bug Fixes
+
+- extended telemetry data for the signal websocket ([#1881](https://github.com/GetStream/stream-video-js/issues/1881)) ([984703d](https://github.com/GetStream/stream-video-js/commit/984703dabb8c6189eaf4d6925421568f6d0fd7fc))
+
+## [1.27.2](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.27.1...@stream-io/video-client-1.27.2) (2025-08-05)
+
+### Bug Fixes
+
+- improved logging and tracing ([#1874](https://github.com/GetStream/stream-video-js/issues/1874)) ([e450ce2](https://github.com/GetStream/stream-video-js/commit/e450ce2a294d6f80480fcc709591c13d9ede79e4))
+
 ## [1.27.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.27.0...@stream-io/video-client-1.27.1) (2025-07-25)
 
 ### Bug Fixes

package/dist/index.browser.es.js

@@ -5914,7 +5914,7 @@ const aggregate = (stats) => {
     return report;
 };
 
-const version = "1.27.1";
+const version = "1.27.3";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -7633,19 +7633,22 @@ class Subscriber extends BasePeerConnection {
 }
 
 const createWebSocketSignalChannel = (opts) => {
-    const { endpoint, onMessage, tag } = opts;
+    const { endpoint, onMessage, tag, tracer } = opts;
     const logger = getLogger(['SfuClientWS', 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);
+        tracer?.trace('signal.ws.error', e);
     });
     ws.addEventListener('close', (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);
+        tracer?.trace('signal.ws.open', e);
     });
     ws.addEventListener('message', (e) => {
         try {
@@ -7655,7 +7658,9 @@ const createWebSocketSignalChannel = (opts) => {
             onMessage(message);
         }
         catch (err) {
-            logger('error', 'Failed to decode a message. Check whether the Proto models match.', { event: e, error: err });
+            const message = 'Failed to decode a message. Check whether the Proto models match.';
+            logger('error', message, { event: e, error: err });
+            tracer?.trace('signal.ws.message.error', message);
         }
     });
     return ws;
@@ -7927,6 +7932,7 @@ class StreamSfuClient {
             this.signalWs = createWebSocketSignalChannel({
                 tag: this.tag,
                 endpoint: `${this.credentials.server.ws_endpoint}?${new URLSearchParams(params).toString()}`,
+                tracer: this.tracer,
                 onMessage: (message) => {
                     this.lastMessageTimestamp = new Date();
                     this.scheduleConnectionCheck();
@@ -7937,9 +7943,13 @@ class StreamSfuClient {
                     this.dispatcher.dispatch(message, this.tag);
                 },
             });
+            let timeoutId;
             this.signalReady = makeSafePromise(Promise.race([
                 new Promise((resolve, reject) => {
+                    let didOpen = false;
                     const onOpen = () => {
+                        didOpen = true;
+                        clearTimeout(timeoutId);
                         this.signalWs.removeEventListener('open', onOpen);
                         resolve(this.signalWs);
                     };
@@ -7947,19 +7957,25 @@ class StreamSfuClient {
                     this.signalWs.addEventListener('close', (e) => {
                         this.handleWebSocketClose(e);
                         // Normally, this shouldn't have any effect, because WS should never emit 'close'
-                        // before emitting 'open'. However, strager things have happened, and we don't
-                        // want to leave signalReady in pending state.
-                        reject(new Error(`SFU WS closed or connection can't be established`));
+                        // before emitting 'open'. However, stranger things have happened, and we don't
+                        // want to leave signalReady in a pending state.
+                        const message = didOpen
+                            ? `SFU WS closed: ${e.code} ${e.reason}`
+                            : `SFU WS connection can't be established: ${e.code} ${e.reason}`;
+                        this.tracer?.trace('signal.close', message);
+                        clearTimeout(timeoutId);
+                        reject(new Error(message));
                     });
                 }),
                 new Promise((resolve, reject) => {
-                    setTimeout(() => reject(new Error('SFU WS connection timed out')), this.joinResponseTimeout);
+                    timeoutId = setTimeout(() => {
+                        const message = `SFU WS connection failed to open after ${this.joinResponseTimeout}ms`;
+                        this.tracer?.trace('signal.timeout', message);
+                        reject(new Error(message));
+                    }, this.joinResponseTimeout);
                 }),
             ]));
         };
-        this.cleanUpWebSocket = () => {
-            this.signalWs.removeEventListener('close', this.handleWebSocketClose);
-        };
         this.handleWebSocketClose = (e) => {
             this.signalWs.removeEventListener('close', this.handleWebSocketClose);
             getTimers().clearInterval(this.keepAliveInterval);
@@ -7971,7 +7987,7 @@ class StreamSfuClient {
             if (this.signalWs.readyState === WebSocket.OPEN) {
                 this.logger('debug', `Closing SFU WS connection: ${code} - ${reason}`);
                 this.signalWs.close(code, `js-client: ${reason}`);
-                this.cleanUpWebSocket();
+                this.signalWs.removeEventListener('close', this.handleWebSocketClose);
             }
             this.dispose();
         };
@@ -8069,7 +8085,6 @@ class StreamSfuClient {
             const current = this.joinResponseTask;
             let timeoutId = undefined;
             const unsubscribe = this.dispatcher.on('joinResponse', (joinResponse) => {
-                this.logger('debug', 'Received joinResponse', joinResponse);
                 clearTimeout(timeoutId);
                 unsubscribe();
                 this.keepAlive();
@@ -8077,7 +8092,9 @@ class StreamSfuClient {
             });
             timeoutId = setTimeout(() => {
                 unsubscribe();
-                current.reject(new Error('Waiting for "joinResponse" has timed out'));
+                const message = `Waiting for "joinResponse" has timed out after ${this.joinResponseTimeout}ms`;
+                this.tracer?.trace('joinRequestTimeout', message);
+                current.reject(new Error(message));
             }, this.joinResponseTimeout);
             const joinRequest = SfuRequest.create({
                 requestPayload: {
@@ -9421,6 +9438,25 @@ const CallTypes = new CallTypesRegistry([
     }),
 ]);
 
+/**
+ * Deactivates MediaStream (stops and removes tracks) to be later garbage collected
+ *
+ * @param stream MediaStream
+ * @returns void
+ */
+const disposeOfMediaStream = (stream) => {
+    if (!stream.active)
+        return;
+    stream.getTracks().forEach((track) => {
+        track.stop();
+    });
+    // @ts-expect-error release() is present in react-native-webrtc and must be called to dispose the stream
+    if (typeof stream.release === 'function') {
+        // @ts-expect-error - release() is present in react-native-webrtc
+        stream.release();
+    }
+};
+
 class BrowserPermission {
     constructor(permission) {
         this.permission = permission;
@@ -9818,24 +9854,6 @@ const deviceIds$ = typeof navigator !== 'undefined' &&
     typeof navigator.mediaDevices !== 'undefined'
     ? getDeviceChangeObserver().pipe(startWith(undefined), concatMap(() => navigator.mediaDevices.enumerateDevices()), shareReplay(1))
     : undefined;
-/**
- * Deactivates MediaStream (stops and removes tracks) to be later garbage collected
- *
- * @param stream MediaStream
- * @returns void
- */
-const disposeOfMediaStream = (stream) => {
-    if (!stream.active)
-        return;
-    stream.getTracks().forEach((track) => {
-        track.stop();
-    });
-    // @ts-expect-error release() is present in react-native-webrtc and must be called to dispose the stream
-    if (typeof stream.release === 'function') {
-        // @ts-expect-error - release() is present in react-native-webrtc
-        stream.release();
-    }
-};
 /**
  * Resolves `default` device id into the real device id. Some browsers (notably,
  * Chromium-based) report device with id `default` among audio input and output
@@ -11849,6 +11867,12 @@ class Call {
                 }
                 catch (err) {
                     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
+                        // to join the call due to some reason (e.g., ended call, expired token...)
+                        throw err;
+                    }
                     const sfuId = this.credentials?.server.edge_name || '';
                     const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
                     sfuJoinFailures.set(sfuId, failures);
@@ -14360,12 +14384,6 @@ class StreamClient {
                 response,
             });
         };
-        this._logApiError = (type, url, error) => {
-            this.logger('error', `client:${type} - Error - url: ${url}`, {
-                url,
-                error,
-            });
-        };
         this.doAxiosRequest = async (type, url, data, options = {}) => {
             if (!options.publicEndpoint) {
                 await Promise.all([
@@ -14412,27 +14430,36 @@ class StreamClient {
                 }
                 this._logApiResponse(type, url, response);
                 this.consecutiveFailures = 0;
-                return this.handleResponse(response);
+                return response.data;
             }
             catch (e /**TODO: generalize error types  */) {
                 e.client_request_id = requestConfig.headers?.['x-client-request-id'];
                 this.consecutiveFailures += 1;
-                if (e.response) {
-                    this._logApiError(type, url, e.response);
-                    /** connection_fallback depends on this token expiration logic */
-                    if (e.response.data.code === KnownCodes.TOKEN_EXPIRED &&
-                        !this.tokenManager.isStatic()) {
-                        if (this.consecutiveFailures > 1) {
-                            await sleep(retryInterval(this.consecutiveFailures));
-                        }
-                        await this.tokenManager.loadToken();
-                        return await this.doAxiosRequest(type, url, data, options);
+                const { response } = e;
+                if (!response || !isErrorResponse(response)) {
+                    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);
+                    if (this.consecutiveFailures > 1) {
+                        await sleep(retryInterval(this.consecutiveFailures));
                     }
-                    return this.handleResponse(e.response);
+                    // refresh and retry the request
+                    await this.tokenManager.loadToken();
+                    return await this.doAxiosRequest(type, url, data, options);
                 }
                 else {
-                    this._logApiError(type, url, e);
-                    throw e;
+                    this.logger('error', `client:${type} url: ${url}`, response);
+                    throw new ErrorFromResponse({
+                        message: `Stream error code ${responseData.code}: ${responseData.message}`,
+                        code: responseData.code ?? null,
+                        unrecoverable: responseData.unrecoverable ?? null,
+                        response: response,
+                        status: status,
+                    });
                 }
             }
         };
@@ -14455,23 +14482,6 @@ class StreamClient {
                 params,
             });
         };
-        this.errorFromResponse = (response) => {
-            const { data, status } = response;
-            return new ErrorFromResponse({
-                message: `Stream error code ${data.code}: ${data.message}`,
-                code: data.code ?? null,
-                unrecoverable: data.unrecoverable ?? null,
-                response: response,
-                status: status,
-            });
-        };
-        this.handleResponse = (response) => {
-            const data = response.data;
-            if (isErrorResponse(response)) {
-                throw this.errorFromResponse(response);
-            }
-            return data;
-        };
         this.dispatchEvent = (event) => {
             this.logger('debug', `Dispatching event: ${event.type}`, event);
             if (!this.listeners)
@@ -14504,7 +14514,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.27.1", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.27.3", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),