iidrak-analytics-react 1.5.0 → 1.5.1

package/metastreamio/metastreamio.network.js

@@ -52,53 +52,35 @@ class MetaStreamIONetwork {
       }
     });
 
-    // Background heartbeat to auto-flush stuck events gracefully
     this._flushInterval = setInterval(() => {
       this.flushEvents();
-    }, 3000); // Poll every 3 seconds for perfect sync
+    }, 3000); // Reverted back to 3 seconds. (Locking guarantees safety)
   }
 
   reset() {
     this.endpoint = null;
+    this._testingPromise = null;
   }
 
   async testConnection() {
-    if (!this.endpoint || this.endpoint === null) {
+    if (this.endpoint) return Promise.resolve(this.endpoint);
+    if (this._testingPromise) return this._testingPromise;
+
+    this._testingPromise = (async () => {
       for (let _e in this.endpoints) {
-        this.endpoint = await this.getData({ endpoint: this.endpoints[_e] })
-          .then((data) => {
-            try {
-              if (data && data.status > 0) {
-                return this.endpoints[_e];
-              }
-              return false;
-            } catch (err) {
-              return false;
-            }
-          })
-          .catch(() => { return false; });
-        if (this.endpoint) {
-          this.logger.log(
-            "network",
-            this.constant.MetaStreamIO_Network_EndpointSet.format(this.endpoint)
-          );
+        let testEp = await this.getData({ endpoint: this.endpoints[_e] });
+        if (testEp && testEp.status > 0) {
+          this.logger.log("network", this.constant.MetaStreamIO_Network_EndpointSet.format(this.endpoints[_e]));
+          this.endpoint = this.endpoints[_e];
           break;
         } else {
-          this.logger.log(
-            "network",
-            this.constant.MetaStreamIO_Network_EndpointTestFailed.format(
-              this.endpoint
-            )
-          );
-          this.logger.log(
-            "network",
-            this.constant.MetaStreamIO_Network_SilentModeEnabled
-          );
+          this.logger.log("network", this.constant.MetaStreamIO_Network_EndpointTestFailed.format(this.endpoints[_e]));
         }
       }
-    }
-
-    return Promise.resolve(this.endpoint);
+      this._testingPromise = null;
+      return this.endpoint;
+    })();
+    return this._testingPromise;
   }
 
   async getData({ endpoint = this.endpoint } = {}) {
@@ -115,14 +97,16 @@ class MetaStreamIONetwork {
       get_config.headers = Object.assign(get_config.headers, this.headers);
     }
 
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3000);
+    get_config.signal = controller.signal;
+
     try {
-      const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 3000));
-      const response = await Promise.race([
-        fetch(endpoint, get_config),
-        timeoutPromise
-      ]);
+      const response = await fetch(endpoint, get_config);
+      clearTimeout(timeoutId);
       return { status: response.status, body: "OK" };
     } catch (err) {
+      clearTimeout(timeoutId);
       return { status: 0, body: String(err) };
     }
   }
@@ -229,13 +213,13 @@ class MetaStreamIONetwork {
       return { status: 200, body: "Stored offline" };
     }
 
-    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 3000));
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3000);
+    post_config.signal = controller.signal;
 
-    await Promise.race([
-      fetch(endpoint, post_config),
-      timeoutPromise
-    ])
+    await fetch(endpoint, post_config)
       .then((response) => {
+        clearTimeout(timeoutId);
         rx.status = response.status;
         let _contentType = response.headers.get("content-type");
         if (!_contentType || !_contentType.includes("application/json")) {
@@ -252,6 +236,7 @@ class MetaStreamIONetwork {
         }
       })
       .catch(async (err) => {
+        clearTimeout(timeoutId);
         this.logger.warn("network", "fetch() error in post()", err.message || err);
         rx.status = 500;
         rx.body = "fetch error";
@@ -303,11 +288,18 @@ class MetaStreamIONetwork {
       // Pre-flight check: Do not spam the Native Bridge with 20 offline events if the server route is down
       const pingEndpoint = this.endpoint || (this.endpoints.length > 0 ? this.endpoints[0] : null);
       if (pingEndpoint) {
-        const pingTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 1500));
-        const routeValid = await Promise.race([
-          fetch(pingEndpoint, { method: "OPTIONS" }),
-          pingTimeout
-        ]).then(() => true).catch(() => false);
+        let routeValid = false;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 1500);
+
+        try {
+          await fetch(pingEndpoint, { method: "OPTIONS", signal: controller.signal });
+          routeValid = true;
+        } catch (err) {
+          routeValid = false;
+        } finally {
+          clearTimeout(timeoutId);
+        }
 
         if (!routeValid) {
           this.logger.log("network", "flushEvents aborted: Node route not fully established natively yet.");
@@ -322,17 +314,17 @@ class MetaStreamIONetwork {
         if (this.headers) {
           reqHeaders = Object.assign(reqHeaders, this.headers);
         }
-        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 3000));
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3000);
 
         try {
-          const response = await Promise.race([
-            fetch(e.endpoint, {
-              method: "POST",
-              headers: reqHeaders,
-              body: JSON.stringify(e.payload),
-            }),
-            timeoutPromise
-          ]);
+          const response = await fetch(e.endpoint, {
+            method: "POST",
+            headers: reqHeaders,
+            body: JSON.stringify(e.payload),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
 
           if (response.ok) {
             this.logger.log("network", "Retried & sent event successfully.");
@@ -340,6 +332,7 @@ class MetaStreamIONetwork {
             this.logger.warn("network", `Retry got non-OK status (${response.status}), dropping event.`);
           }
         } catch (err) {
+          clearTimeout(timeoutId);
           this.logger.log("network", "Retry failed (still offline or bad host), keeping event.", err.message);
           remainingEvents.push(e);
         }

package/metastreamio/metastreamio.queue.js

@@ -57,12 +57,19 @@ Queue.prototype.peek = function () {
  * The MetaStreamIO SAUCE
  *
  */
-Queue.prototype.run = function (callback) {
-  while (this.size() > 0) {
-    callback(this.dequeue()).catch(err => {
-      console.error('<queue callback>', err);
-    });
+Queue.prototype.run = async function (callback) {
+  if (this._isRunning) return;
+  this._isRunning = true;
+
+  try {
+    while (this.size() > 0) {
+      await callback(this.dequeue()).catch(err => {
+        console.error('<queue callback>', err);
+      });
+    }
+  } finally {
+    this._isRunning = false;
   }
 };
 
-export {Queue};
+export { Queue };

package/metastreamio/metastreamio.recorder.js

@@ -139,9 +139,14 @@ class MetaStreamIORecorder {
             // Note: We use a separate fetch here because the payload format is different from standard analytics
             const url = `${this.endpoint}/api/apps/${this.app_id}/sessions`;
             this.logger.log("recorder", `Sending session creation request to: ${url}`);
+
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 3000);
+
             await fetch(url, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
+                signal: controller.signal,
                 body: JSON.stringify({
                     session_id: this.sessionId,
                     device_info: {
@@ -152,6 +157,7 @@ class MetaStreamIORecorder {
                     }
                 })
             }).then(async res => {
+                clearTimeout(timeoutId);
                 this.logger.log("recorder", "Session creation response status: " + res.status);
                 if (res.ok) {
                     const data = await res.json();
@@ -164,6 +170,7 @@ class MetaStreamIORecorder {
                     this.logger.error("recorder", "Failed to start session on recording server: " + res.status);
                 }
             }).catch(e => {
+                clearTimeout(timeoutId);
                 this.logger.error("recorder", "Connection error to recording server: " + e + " to " + url);
             });
 
@@ -200,6 +207,9 @@ class MetaStreamIORecorder {
         console.log("Starting loop");
         this.intervalId = setInterval(async () => {
             if (!viewRef.current) return;
+            if (this._isCapturing) return;
+
+            this._isCapturing = true;
 
             try {
                 // Capture as base64 for comparison and direct upload
@@ -241,13 +251,15 @@ class MetaStreamIORecorder {
                     // Measure privacy zones
                     const zones = await this.measurePrivacyZones(viewRef);
 
-                    console.log("DBG:: Uploading frame with " + zones.length + " privacy zones");
-                    this.uploadFrame(base64, isDuplicate, zones);
+                    // console.log("DBG:: Uploading frame with " + zones.length + " privacy zones");
+                    await this.uploadFrame(base64, isDuplicate, zones);
                     this.lastUploadTime = now;
                     this.lastBase64 = base64;
                 }
             } catch (e) {
                 // Silent fail on capture error to avoid log spam
+            } finally {
+                this._isCapturing = false;
             }
         }, intervalMs);
     }
@@ -277,13 +289,18 @@ class MetaStreamIORecorder {
         }
 
         try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 1500);
+
             await fetch(`${this.endpoint}/api/apps/${this.app_id}/sessions/${this.recorderSessionId}/screenshot`, {
                 method: 'POST',
                 body: formData,
                 headers: {
                     'Content-Type': 'multipart/form-data',
-                }
+                },
+                signal: controller.signal
             });
+            clearTimeout(timeoutId);
         } catch (e) {
             // Network error, drop frame
         }
@@ -304,11 +321,15 @@ class MetaStreamIORecorder {
         };
 
         try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 1500);
+
             fetch(`${this.endpoint}/api/apps/${this.app_id}/sessions/${this.recorderSessionId}/events`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify([event])
-            }).catch(() => { });
+                body: JSON.stringify([event]),
+                signal: controller.signal
+            }).then(() => clearTimeout(timeoutId)).catch(() => clearTimeout(timeoutId));
         } catch (e) { }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iidrak-analytics-react",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "react native client for metastreamio",
   "peerDependencies": {
     "react-native-mmkv": ">=4.0.0",