@stream-io/video-client 0.0.1-alpha.124 → 0.0.1-alpha.126

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [0.0.1-alpha.126](https://github.com/GetStream/stream-video-js/compare/client0.0.1-alpha.125...client0.0.1-alpha.126) (2023-05-08)
+
+
+### Features
+
+* **latency:** breadth-first time-boxed latency measurement ([#467](https://github.com/GetStream/stream-video-js/issues/467)) ([6d66003](https://github.com/GetStream/stream-video-js/commit/6d660032064667586902a9b410ee6dabfcc6b7ba))
+
+
+
+## [0.0.1-alpha.125](https://github.com/GetStream/stream-video-js/compare/client0.0.1-alpha.124...client0.0.1-alpha.125) (2023-05-08)
+
+
+
 ## [0.0.1-alpha.124](https://github.com/GetStream/stream-video-js/compare/client0.0.1-alpha.123...client0.0.1-alpha.124) (2023-05-05)
 
 

package/dist/index.browser.es.js

@@ -7093,39 +7093,64 @@ const registerRingingCallEventHandlers = (call) => {
 const toSeconds = (ms) => ms / 1000;
 /**
  * Measures the latency of the current client to the given endpoint.
- * Uses HTML Image tag in order to avoid CORS issues.
  *
  * @param endpoint the endpoint.
- * @param rounds the number of measuring rounds to perform.
  * @param timeoutAfterMs the request cancellation period.
  */
-const measureResourceLoadLatencyTo = (endpoint, rounds = 3, timeoutAfterMs = 1500) => __awaiter(void 0, void 0, void 0, function* () {
-    const measurements = [];
-    yield Promise.all(Array(rounds)
-        .fill(undefined)
-        .map(() => __awaiter(void 0, void 0, void 0, function* () {
-        const start = Date.now();
-        const controller = new AbortController();
-        const abortTimeout = setTimeout(() => {
-            controller.abort();
-        }, timeoutAfterMs);
-        try {
-            const src = new URL(endpoint);
-            src.searchParams.set('r', `js_${Math.random() * 10000000}`);
-            yield fetch(src.toString(), {
-                signal: controller.signal,
-            }).then((response) => response.blob());
-            const latency = Date.now() - start;
-            measurements.push(toSeconds(latency));
-        }
-        catch (e) {
-            console.debug(`failed to measure latency to ${endpoint}`, e);
-            measurements.push(-1); // indicate error in measurement
-        }
+const measureResourceLoadLatencyTo = (endpoint, timeoutAfterMs = 1000) => __awaiter(void 0, void 0, void 0, function* () {
+    const start = Date.now();
+    const controller = new AbortController();
+    const abortTimeout = setTimeout(() => {
+        controller.abort();
+    }, timeoutAfterMs);
+    try {
+        const src = new URL(endpoint);
+        src.searchParams.set('r', `js_${Math.random() * 10000000}`);
+        yield fetch(src.toString(), {
+            signal: controller.signal,
+        });
+        const latency = Date.now() - start;
+        return toSeconds(latency);
+    }
+    catch (e) {
+        console.debug(`failed to measure latency to ${endpoint}`, e);
+        return -1; // indicate error in measurement
+    }
+    finally {
         // clear timeout in case fetch completes before timeout
         clearTimeout(abortTimeout);
-    })));
-    return measurements;
+    }
+});
+/**
+ * Measures the latency of the current client to the given edges.
+ *
+ * All measurements run in parallel,
+ * and the whole process is limited by the given timeout.
+ *
+ * @param edges the edges to measure latency to.
+ * @param attempts the number of attempts to measure latency.
+ * @param attemptTimeoutAfterMs the request cancellation period per measurement.
+ * @param measureTimeoutAfterMs the hard-limit for the whole measure process.
+ */
+const measureLatencyToEdges = (edges, { attempts = 3, attemptTimeoutAfterMs = 1000, measureTimeoutAfterMs = 1200, } = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const latencyByEdge = {};
+    const measurements = [];
+    const start = Date.now();
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        for (const edge of edges) {
+            measurements.push(measureResourceLoadLatencyTo(edge.latency_url, attemptTimeoutAfterMs).then((latency) => {
+                var _a;
+                var _b;
+                ((_a = latencyByEdge[_b = edge.name]) !== null && _a !== void 0 ? _a : (latencyByEdge[_b] = [])).push(latency);
+            }));
+        }
+    }
+    yield Promise.race([
+        Promise.all(measurements),
+        new Promise((resolve) => setTimeout(resolve, measureTimeoutAfterMs)),
+    ]);
+    console.log(`finished measuring latency to ${edges.length} edges in ${Date.now() - start}ms.`);
+    return latencyByEdge;
 });
 
 const getCascadingModeParams = () => {
@@ -7167,12 +7192,8 @@ const join = (httpClient, type, id, data) => __awaiter(void 0, void 0, void 0, f
     };
 });
 const getCallEdgeServer = (httpClient, type, id, edges) => __awaiter(void 0, void 0, void 0, function* () {
-    const latencyByEdge = {};
-    yield Promise.all(edges.map((edge) => __awaiter(void 0, void 0, void 0, function* () {
-        latencyByEdge[edge.name] = yield measureResourceLoadLatencyTo(edge.latency_url);
-    })));
     const data = {
-        latency_measurements: latencyByEdge,
+        latency_measurements: yield measureLatencyToEdges(edges),
     };
     // FIXME OL: remove this once cascading is enabled by default
     const cascadingModeParams = getCascadingModeParams();
@@ -10250,7 +10271,7 @@ class StreamClient {
     }
     getUserAgent() {
         return (this.userAgent ||
-            `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${"0.0.1-alpha.123"}`);
+            `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${"0.0.1-alpha.125"}`);
     }
     setUserAgent(userAgent) {
         this.userAgent = userAgent;