iidrak-analytics-react 1.3.0 → 1.5.1

package/README.md

@@ -18,8 +18,13 @@ This package relies on several peer dependencies for device info, storage, and s
 ```bash
 npm install iidrak-analytics-react
 
-# Install required peer dependencies
-npm install react-native-mmkv react-native-nitro-modules @react-native-community/netinfo react-native-device-info react-native-view-shot react-native-safe-area-context
+# Install required peer dependencies. For storage, choose ONE: MMKV or AsyncStorage
+npm install react-native-nitro-modules react-native-mmkv
+# OR
+npm install @react-native-async-storage/async-storage
+
+# Install core peer dependencies
+npm install @react-native-community/netinfo react-native-device-info react-native-view-shot react-native-safe-area-context
 ```
 
 **iOS Users**: after installing, remember to run:
@@ -44,6 +49,13 @@ The configuration object requires strict structure for `app`, `config`, and `use
 ```javascript
 import { MetaStreamIO, MetaStreamProvider } from 'iidrak-analytics-react';
 
+// Recommended: Import your preferred storage engine
+import { createMMKV } from 'react-native-mmkv';
+const mmkvStorage = createMMKV();
+
+// Alternatively, import AsyncStorage
+// import AsyncStorage from '@react-native-async-storage/async-storage';
+
 const iidrakConfig = {
   // Application Details
   app: {
@@ -70,6 +82,17 @@ const iidrakConfig = {
     sessionLength: 1800,         // Session timeout in seconds (e.g. 30 mins)
     quality: 0.1,                // Recording quality (0.1 - 1.0)
     fps: 2,                      // Frames Per Second for recording
+
+    // Provide the storage engine to the SDK.
+    // Why wrap MMKV? The SDK strictly expects an asynchronous `getItem/setItem` Interface.
+    // MMKV v4 is completely synchronous C++. This wrapper bridges MMKV into a standard Promise architecture.
+    storageEngine: {
+      getItem: async (key) => mmkvStorage.getString(key) || null,
+      setItem: async (key, value) => { mmkvStorage.set(key, value); return Promise.resolve(); },
+      removeItem: async (key) => { mmkvStorage.remove(key); return Promise.resolve(); }
+    },
+    // For AsyncStorage, no wrapper is needed because it natively uses Promises:
+    // storageEngine: AsyncStorage,
   },
 
   // Initial User Info

package/metastreamio/metastreamio.environment.js

@@ -56,82 +56,87 @@ class MetaStreamIOEnvironment {
   }
 
   async logAppInfo() {
-    let app_id = null;
-    let first_installation_time = null;
-    let installation_id = null;
-    let install_referrer = null;
-    let last_update_time = null;
-    let version = null;
-
-    app_id = DeviceInfo.getBundleId() ? DeviceInfo.getBundleId() : null;
-
-    first_installation_time = await DeviceInfo.getFirstInstallTime()
-      .then((result) => {
-        if (this.date.validateDatetime(result)) {
-          return result;
-        } else {
+    if (this._appInfoCached) return this._appInfoCached;
+    if (this._appInfoPromise) return this._appInfoPromise;
+
+    this._appInfoPromise = (async () => {
+      let app_id = null;
+      let first_installation_time = null;
+      let installation_id = null;
+      let install_referrer = null;
+      let last_update_time = null;
+      let version = null;
+
+      app_id = DeviceInfo.getBundleId() ? DeviceInfo.getBundleId() : null;
+
+      first_installation_time = await DeviceInfo.getFirstInstallTime()
+        .then((result) => {
+          if (this.date.validateDatetime(result)) {
+            return result;
+          } else {
+            return null;
+          }
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
           return null;
-        }
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-        return null;
-      });
+        });
 
-    installation_id = "deprecated"; // Constants.installationId;
-
-    install_referrer = await DeviceInfo.getInstallReferrer()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-        return null;
-      });
+      installation_id = "deprecated"; // Constants.installationId;
 
-    last_update_time = await DeviceInfo.getLastUpdateTime()
-      .then((result) => {
-        if (this.date.validateDatetime(result)) {
+      install_referrer = await DeviceInfo.getInstallReferrer()
+        .then((result) => {
           return result;
-        } else {
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
           return null;
-        }
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-        return null;
-      });
-
-    version = DeviceInfo.getVersion() ? DeviceInfo.getVersion() : null;
-
-    this.app_info = new AppInfoModel({
-      first_installation_time: first_installation_time,
-      id: app_id,
-      installation_id: installation_id,
-      install_referrer: install_referrer,
-      last_update_time: last_update_time,
-      version: version,
-    });
+        });
+
+      last_update_time = await DeviceInfo.getLastUpdateTime()
+        .then((result) => {
+          if (this.date.validateDatetime(result)) {
+            return result;
+          } else {
+            return null;
+          }
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+          return null;
+        });
 
-    this.logger.log(
-      this.constant.MetaStreamIO_Logger_Category_Environment,
-      this.constant.MetaStreamIO_Environment_AppInfo.format(
-        JSON.stringify(this.app_info)
-      )
-    );
+      version = DeviceInfo.getVersion() ? DeviceInfo.getVersion() : null;
 
-    return this.app_info.json();
+      this.app_info = new AppInfoModel({
+        first_installation_time: first_installation_time,
+        id: app_id,
+        installation_id: installation_id,
+        install_referrer: install_referrer,
+        last_update_time: last_update_time,
+        version: version,
+      });
 
-    // return Promise.resolve(this.app_info.json());
+      this.logger.log(
+        this.constant.MetaStreamIO_Logger_Category_Environment,
+        this.constant.MetaStreamIO_Environment_AppInfo.format(
+          JSON.stringify(this.app_info)
+        )
+      );
+
+      this._appInfoCached = this.app_info.json();
+      return this._appInfoCached;
+    })();
+    return this._appInfoPromise;
   }
 
   async getAppPerformance() {
@@ -185,146 +190,153 @@ class MetaStreamIOEnvironment {
   }
 
   async logDevice() {
-    let brand,
-      device_type,
-      model,
-      operating_system,
-      operating_system_version,
-      pin_or_fingerprint_set,
-      screen_width,
-      screen_height,
-      storage_total,
-      storage_free,
-      supported_architectures,
-      timezone_offset_sec,
-      total_memory,
-      unique_device_id,
-      used_memory;
-
-    brand = await DeviceInfo.getBrand();
-
-    device_type = await DeviceInfo.getDeviceType();
-
-    model = DeviceInfo.getModel();
-
-    operating_system = DeviceInfo.getSystemName();
-
-    operating_system_version = DeviceInfo.getSystemVersion();
-
-    try {
-      screen_height = Math.round(Dimensions.get("window").height);
-    } catch {
-      screen_height = null;
-    }
-
-    try {
-      screen_width = Math.round(Dimensions.get("window").width);
-    } catch {
-      screen_width = null;
-    }
-
-    storage_free = await DeviceInfo.getFreeDiskStorage()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    storage_total = await DeviceInfo.getTotalDiskCapacity()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    supported_architectures = await DeviceInfo.supportedAbis()
-      .then((result) => {
-        return result.join(",");
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    total_memory = await DeviceInfo.getTotalMemory()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    unique_device_id = DeviceInfo.getUniqueId()
-      ? DeviceInfo.getUniqueId()
-      : null;
-
-    used_memory = await DeviceInfo.getUsedMemory()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    try {
-      timezone_offset_sec = this.date.getDeviceTimezoneOffset();
-    } catch {
-      timezone_offset_sec = null;
-    }
-
-    pin_or_fingerprint_set = await DeviceInfo.isPinOrFingerprintSet()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
+    if (this._deviceCached) return this._deviceCached;
+    if (this._devicePromise) return this._devicePromise;
+
+    this._devicePromise = (async () => {
+      let brand,
+        device_type,
+        model,
+        operating_system,
+        operating_system_version,
+        pin_or_fingerprint_set,
+        screen_width,
+        screen_height,
+        storage_total,
+        storage_free,
+        supported_architectures,
+        timezone_offset_sec,
+        total_memory,
+        unique_device_id,
+        used_memory;
+
+      brand = await DeviceInfo.getBrand();
+
+      device_type = await DeviceInfo.getDeviceType();
+
+      model = DeviceInfo.getModel();
+
+      operating_system = DeviceInfo.getSystemName();
+
+      operating_system_version = DeviceInfo.getSystemVersion();
+
+      try {
+        screen_height = Math.round(Dimensions.get("window").height);
+      } catch {
+        screen_height = null;
+      }
+
+      try {
+        screen_width = Math.round(Dimensions.get("window").width);
+      } catch {
+        screen_width = null;
+      }
+
+      storage_free = await DeviceInfo.getFreeDiskStorage()
+        .then((result) => {
+          return result;
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      storage_total = await DeviceInfo.getTotalDiskCapacity()
+        .then((result) => {
+          return result;
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      supported_architectures = await DeviceInfo.supportedAbis()
+        .then((result) => {
+          return result.join(",");
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      total_memory = await DeviceInfo.getTotalMemory()
+        .then((result) => {
+          return result;
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      unique_device_id = DeviceInfo.getUniqueId()
+        ? DeviceInfo.getUniqueId()
+        : null;
+
+      used_memory = await DeviceInfo.getUsedMemory()
+        .then((result) => {
+          return result;
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      try {
+        timezone_offset_sec = this.date.getDeviceTimezoneOffset();
+      } catch {
+        timezone_offset_sec = null;
+      }
+
+      pin_or_fingerprint_set = await DeviceInfo.isPinOrFingerprintSet()
+        .then((result) => {
+          return result;
+        })
+        .catch((err) => {
+          this.logger.warn(
+            this.constant.MetaStreamIO_Logger_Category_Environment,
+            err
+          );
+        });
+
+      this.device = new DeviceModel({
+        brand: brand,
+        device_type: device_type,
+        model: model,
+        operating_system: operating_system,
+        operating_system_version: operating_system_version,
+        pin_or_fingerprint_set: pin_or_fingerprint_set,
+        screen_height: screen_height,
+        screen_width: screen_width,
+        storage_free: storage_free,
+        storage_total: storage_total,
+        supported_architectures: supported_architectures,
+        timezone_offset_sec: timezone_offset_sec,
+        total_memory: total_memory,
+        unique_device_id: unique_device_id,
+        used_memory: used_memory,
       });
 
-    this.device = new DeviceModel({
-      brand: brand,
-      device_type: device_type,
-      model: model,
-      operating_system: operating_system,
-      operating_system_version: operating_system_version,
-      pin_or_fingerprint_set: pin_or_fingerprint_set,
-      screen_height: screen_height,
-      screen_width: screen_width,
-      storage_free: storage_free,
-      storage_total: storage_total,
-      supported_architectures: supported_architectures,
-      timezone_offset_sec: timezone_offset_sec,
-      total_memory: total_memory,
-      unique_device_id: unique_device_id,
-      used_memory: used_memory,
-    });
-
-    this.logger.log(
-      this.constant.MetaStreamIO_Logger_Category_Environment,
-      this.constant.MetaStreamIO_Environment_Device.format(
-        JSON.stringify(this.device)
-      )
-    );
-
-    return Promise.resolve(this.device.json());
+      this.logger.log(
+        this.constant.MetaStreamIO_Logger_Category_Environment,
+        this.constant.MetaStreamIO_Environment_Device.format(
+          JSON.stringify(this.device)
+        )
+      );
+
+      this._deviceCached = this.device.json();
+      return this._deviceCached;
+    })();
+    return this._devicePromise;
   }
 
   async getNetworkInfo() {
@@ -338,68 +350,66 @@ class MetaStreamIOEnvironment {
   }
 
   async logNetworkInfo() {
-    let carrier,
-      carrier_iso_country_code,
-      cellular_generation,
-      mobile_country_code,
-      mobile_network_code,
-      network_state_type,
-      net_info;
-
-    carrier = await DeviceInfo.getCarrier()
-      .then((result) => {
-        return result;
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
-
-    net_info = await NetInfo.fetch()
-      .then((state) => {
-        return {
+    if (this._networkCached && (Date.now() - this._networkCachedTime < 5000)) {
+      return this._networkCached;
+    }
+    if (this._networkPromise) return this._networkPromise;
+
+    this._networkPromise = (async () => {
+      let carrier,
+        carrier_iso_country_code,
+        cellular_generation,
+        mobile_country_code,
+        mobile_network_code,
+        network_state_type,
+        net_info;
+
+      carrier = await Promise.race([
+        DeviceInfo.getCarrier().then(r => r).catch(() => null),
+        new Promise(res => setTimeout(() => res(null), 500))
+      ]);
+
+      net_info = await Promise.race([
+        NetInfo.fetch().then((state) => ({
           connection_type: state.type,
           connection_active: state.isConnected,
-          cellular_generation:
-            state.type === "cellular" ? state.details.cellularGeneration : null,
-        };
-      })
-      .catch((err) => {
-        this.logger.warn(
-          this.constant.MetaStreamIO_Logger_Category_Environment,
-          err
-        );
-      });
+          cellular_generation: state.type === "cellular" ? state.details.cellularGeneration : null,
+        })).catch(() => ({ connection_type: "unknown", connection_active: true, cellular_generation: null })),
+        new Promise(res => setTimeout(() => res({ connection_type: "unknown", connection_active: true, cellular_generation: null }), 500))
+      ]);
 
-    carrier_iso_country_code = null;
+      carrier_iso_country_code = null;
 
-    cellular_generation = net_info.cellular_generation;
+      cellular_generation = net_info.cellular_generation;
 
-    mobile_country_code = null;
+      mobile_country_code = null;
 
-    mobile_network_code = null;
+      mobile_network_code = null;
 
-    network_state_type = net_info.connection_type;
+      network_state_type = net_info.connection_type;
 
-    this.logger.log(
-      this.constant.MetaStreamIO_Logger_Category_Environment,
-      this.constant.MetaStreamIO_Environment_Network.format(
-        JSON.stringify(this.network_info)
-      )
-    );
+      this.logger.log(
+        this.constant.MetaStreamIO_Logger_Category_Environment,
+        this.constant.MetaStreamIO_Environment_Network.format(
+          JSON.stringify(this.network_info)
+        )
+      );
 
-    this.network_info = new NetworkInfoModel({
-      carrier: carrier,
-      carrier_iso_country_code: carrier_iso_country_code,
-      cellular_generation: cellular_generation,
-      mobile_country_code: mobile_country_code,
-      mobile_network_code: mobile_network_code,
-      network_state_type: network_state_type,
-    });
+      this.network_info = new NetworkInfoModel({
+        carrier: carrier,
+        carrier_iso_country_code: carrier_iso_country_code,
+        cellular_generation: cellular_generation,
+        mobile_country_code: mobile_country_code,
+        mobile_network_code: mobile_network_code,
+        network_state_type: network_state_type,
+      });
 
-    return Promise.resolve(this.network_info.json());
+      this._networkCached = this.network_info.json();
+      this._networkCachedTime = Date.now();
+      this._networkPromise = null;
+      return this._networkCached;
+    })();
+    return this._networkPromise;
   }
 }
 

package/metastreamio/metastreamio.interface.js

@@ -82,6 +82,7 @@ class MetaStreamIO {
       silentMode: this.config.silentMode,
       endpoints: this.appConfig.endpoints,
       headers: this.appConfig.headers,
+      storageEngine: this.config.storageEngine,
     });
     this.account = new MetaStreamIOAccountData({
       constants: this.constant,
@@ -469,7 +470,7 @@ class MetaStreamIO {
             );
             return Promise.resolve(event_data);
           } else {
-            this.logger.error(
+            this.logger.warn(
               "event",
               this.constant.MetaStreamIO_Log_EventTrackFailed.format(_data)
             );
@@ -480,13 +481,14 @@ class MetaStreamIO {
             return Promise.reject(_data);
           }
         })
-        .catch((err) => {
-          this.logger.error("event", "<post_event> could not post: " + err);
-          return Promise.reject(err);
+        .catch(async (err) => {
+          this.logger.warn("event", "<post_event> could not post: " + (err.message || JSON.stringify(err)));
+          await this.network.storeOfflineEvent(this.network.endpoint, event_data);
+          return Promise.resolve(event_data); // Resolve to deque, since it's now safely offline
         });
       return status;
     } else {
-      this.logger.error("event", "<post_event> event_data is undefined");
+      this.logger.warn("event", "<post_event> event_data is undefined");
     }
   }
 
@@ -515,7 +517,7 @@ class MetaStreamIO {
             return Promise.resolve();
           })
           .catch((err) => {
-            this.logger.error(
+            this.logger.warn(
               "event",
               "<runQueue> this.post_event failed: " + err
             );
@@ -526,7 +528,7 @@ class MetaStreamIO {
             try {
               this.queue.enqueue(event);
             } catch (err) {
-              this.logger.error(
+              this.logger.warn(
                 "event",
                 "<runQueue> could not enqueue event: " + err
               );

package/metastreamio/metastreamio.network.js

@@ -1,13 +1,6 @@
 "use strict";
 
 import { strf } from "./string.format.js";
-import { createMMKV } from "react-native-mmkv";
-const mmkvStorage = createMMKV();
-const AsyncStorage = {
-  getItem: async (key) => mmkvStorage.getString(key) || null,
-  setItem: async (key, value) => { mmkvStorage.set(key, value); return Promise.resolve(); },
-  removeItem: async (key) => { mmkvStorage.delete(key); return Promise.resolve(); }
-};
 import NetInfo from "@react-native-community/netinfo";
 
 strf();
@@ -21,7 +14,7 @@ const EVENT_QUEUE_KEY = "metastream_offline_events";
  */
 
 class MetaStreamIONetwork {
-  constructor({ constants, endpoints, logger, silentMode, headers } = {}) {
+  constructor({ constants, endpoints, logger, silentMode, headers, storageEngine } = {}) {
     this.silentMode = silentMode;
     this.constant = constants;
     this.endpoint = null;
@@ -29,13 +22,23 @@ class MetaStreamIONetwork {
     this.headers = headers;
     this.logger = logger;
 
+    // Use provided storageEngine from config or fallback to a transient in-memory store
+    this.storageEngine = storageEngine || {
+      _memory: {},
+      getItem: async (key) => this.storageEngine._memory[key] || null,
+      setItem: async (key, value) => { this.storageEngine._memory[key] = value; return Promise.resolve(); },
+      removeItem: async (key) => { delete this.storageEngine._memory[key]; return Promise.resolve(); }
+    };
+
     // Initialize offline handling
     this.initOfflineHandling();
   }
 
   initOfflineHandling() {
+    this.isOnline = true; // Default assume online, Listener updates it
     // Flush on startup if connected
     NetInfo.fetch().then(state => {
+      this.isOnline = state.isConnected;
       if (state.isConnected) {
         this.flushEvents();
       }
@@ -43,64 +46,50 @@ class MetaStreamIONetwork {
 
     // Flush when network comes back online
     NetInfo.addEventListener(state => {
+      this.isOnline = state.isConnected;
       if (state.isConnected) {
         this.flushEvents();
       }
     });
+
+    this._flushInterval = setInterval(() => {
+      this.flushEvents();
+    }, 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.status === 200) {
-                return this.endpoints[_e];
-              }
-            } catch (err) {
-              return false;
-            }
-          })
-          .catch(() => { });
-        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 } = {}) {
-    var rx;
-
     let get_config = {
       method: "GET",
-      // mode: "no-cors", // required for local testing
       cache: "no-cache",
       credentials: "same-origin",
-      redirect: "follow", // manual, *follow, error
-      referrerPolicy: "no-referrer", // no-referrer, *client
+      redirect: "follow",
+      referrerPolicy: "no-referrer",
       headers: {},
     };
 
@@ -108,38 +97,17 @@ 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 {
-      await fetch(endpoint, get_config)
-        .then((response) => {
-          const contentType = response.headers.get("content-type");
-          if (!contentType || !contentType.includes("application/json")) {
-            return null;
-          } else {
-            return response;
-          }
-        })
-        .catch((err) => {
-          return Promise.resolve(err);
-        })
-        .then(async (response) => {
-          rx = {
-            body: await response.json(),
-            status: response.status,
-          };
-        })
-        .catch((err) => {
-          return {
-            body: err,
-            status: 400,
-          };
-        });
-      return rx;
+      const response = await fetch(endpoint, get_config);
+      clearTimeout(timeoutId);
+      return { status: response.status, body: "OK" };
     } catch (err) {
-      return Promise.reject(err);
-      throw this.constant.MetaStreamIO_Network_GetDataIssue.format(
-        err,
-        endpoint
-      );
+      clearTimeout(timeoutId);
+      return { status: 0, body: String(err) };
     }
   }
 
@@ -161,12 +129,25 @@ class MetaStreamIONetwork {
       };
     }
 
+    if (!this.isOnline) {
+      this.logger.log("network", "Offline detected in postData. Storing event.");
+      const fallbackEndpoint = this.endpoints.length > 0 ? this.endpoints[0] : null;
+      if (fallbackEndpoint) {
+        await this.storeOfflineEvent(fallbackEndpoint + (endpoint ? endpoint : ""), data);
+        return {
+          body: "Stored offline",
+          status: 200
+        };
+      }
+    }
+
     if (!this.endpoint) {
-      _endpoint = await this.testConnection()
-        .then((rx_endpoint) => {
-          return Promise.resolve(rx_endpoint + (endpoint ? endpoint : ""));
-        })
-        .catch((err) => err);
+      const rx_endpoint = await this.testConnection().catch(() => null);
+      if (rx_endpoint) {
+        _endpoint = rx_endpoint + (endpoint ? endpoint : "");
+      } else {
+        _endpoint = null;
+      }
     }
 
     if (_endpoint) {
@@ -204,6 +185,9 @@ class MetaStreamIONetwork {
   }
 
   async post({ data = {}, endpoint = this.endpoint } = {}) {
+    // Non-blocking trigger to flush stuck offline events (if any)
+    this.flushEvents();
+
     let rx = {};
 
     let post_config = {
@@ -223,95 +207,160 @@ class MetaStreamIONetwork {
       post_config.headers = Object.assign(post_config.headers, this.headers);
     }
 
-    let isOffline = false;
-    await NetInfo.fetch().then(state => {
-      if (!state.isConnected) {
-        isOffline = true;
-      }
-    });
-
-    if (isOffline) {
+    if (!this.isOnline) {
       this.logger.log("network", "Offline detected. Storing event.");
       await this.storeOfflineEvent(endpoint, data);
       return { status: 200, body: "Stored offline" };
     }
 
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3000);
+    post_config.signal = controller.signal;
+
     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")) {
           return null;
         } else {
-          rx.status = response.status;
           return response;
         }
       })
       .then(async (response) => {
-        rx.body = await response.json();
+        if (response) {
+          rx.body = await response.json();
+        } else {
+          rx.body = "OK";
+        }
       })
       .catch(async (err) => {
-        this.logger.error("network", "fetch() response", err);
-        // Store offline on network error
-        await this.storeOfflineEvent(endpoint, data);
-        rx.status = 200; // Treat as success to deque
-        rx.body = "Stored offline on error";
+        clearTimeout(timeoutId);
+        this.logger.warn("network", "fetch() error in post()", err.message || err);
+        rx.status = 500;
+        rx.body = "fetch error";
+        throw err;
       });
 
     return rx;
   }
 
+  async _getQueue() {
+    try {
+      const raw = await this.storageEngine.getItem(EVENT_QUEUE_KEY);
+      if (!raw) return [];
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+
   async storeOfflineEvent(endpoint, payload) {
     try {
-      const existing = JSON.parse(await AsyncStorage.getItem(EVENT_QUEUE_KEY)) || [];
+      const existing = await this._getQueue();
       const newEvent = {
         endpoint,
         payload,
         failedAt: new Date().toISOString(),
       };
       existing.push(newEvent);
-      await AsyncStorage.setItem(EVENT_QUEUE_KEY, JSON.stringify(existing));
+      await this.storageEngine.setItem(EVENT_QUEUE_KEY, JSON.stringify(existing));
       this.logger.log("network", `Stored event locally. Queue size: ${existing.length}`);
     } catch (error) {
-      this.logger.error("network", "Failed to store event:", error);
+      this.logger.error("network", "Failed to store event:", error.message || error);
     }
   }
 
   async flushEvents() {
+    if (this._isFlushing) return;
+    this._isFlushing = true;
+
     try {
-      const stored = JSON.parse(await AsyncStorage.getItem(EVENT_QUEUE_KEY)) || [];
+      const stored = await this._getQueue();
       if (stored.length === 0) {
         return;
       }
 
       this.logger.log("network", `Flushing ${stored.length} stored event(s)...`);
+
+      // 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) {
+        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.");
+          return;
+        }
+      }
+
       const remainingEvents = [];
 
       for (const e of stored) {
+        let reqHeaders = { "Content-Type": "application/json" };
+        if (this.headers) {
+          reqHeaders = Object.assign(reqHeaders, this.headers);
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3000);
+
         try {
           const response = await fetch(e.endpoint, {
             method: "POST",
-            headers: { "Content-Type": "application/json" },
+            headers: reqHeaders,
             body: JSON.stringify(e.payload),
+            signal: controller.signal
           });
+          clearTimeout(timeoutId);
 
           if (response.ok) {
-            this.logger.log("network", "Retried & sent event");
+            this.logger.log("network", "Retried & sent event successfully.");
           } else {
-            // Drop event if server rejects it (4xx, 5xx), avoid infinite loop
-            this.logger.warn("network", "Retry failed with non-OK status, dropping event");
+            this.logger.warn("network", `Retry got non-OK status (${response.status}), dropping event.`);
           }
         } catch (err) {
-          // Keep if network error
+          clearTimeout(timeoutId);
+          this.logger.log("network", "Retry failed (still offline or bad host), keeping event.", err.message);
           remainingEvents.push(e);
         }
       }
 
-      await AsyncStorage.setItem(EVENT_QUEUE_KEY, JSON.stringify(remainingEvents));
+      const currentQueue = await this._getQueue();
+      // Only keep events that were just inserted (after we started flushing)
+      // We assume new events were appended to the end of the array.
+      let newAdditions = [];
+      if (currentQueue.length > stored.length) {
+        newAdditions = currentQueue.slice(stored.length);
+      }
+
+      const updatedQueue = [...remainingEvents, ...newAdditions];
+
+      if (updatedQueue.length > 0) {
+        await this.storageEngine.setItem(EVENT_QUEUE_KEY, JSON.stringify(updatedQueue));
+      } else {
+        await this.storageEngine.removeItem(EVENT_QUEUE_KEY);
+      }
+
       if (remainingEvents.length < stored.length) {
-        this.logger.log("network", `Flush complete. Remaining: ${remainingEvents.length}`);
+        this.logger.log("network", `Flush complete. Remaining: ${updatedQueue.length}`);
       }
     } catch (error) {
-      this.logger.error("network", "Failed to flush events:", error);
+      this.logger.warn("network", "Failed to flush events:", error.message || error);
+    } finally {
+      this._isFlushing = false;
     }
   }
 

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/metastreamio/models/constructor.config.js

@@ -12,6 +12,7 @@ export class ConfigConstructorModel {
     quality = null,
     fps = null,
     recordingEndpoint = null,
+    storageEngine = null,
   } = {}) {
     this.logging = logging;
     this.loggingLevel = loggingLevel;
@@ -26,6 +27,7 @@ export class ConfigConstructorModel {
     this.quality = quality;
     this.fps = fps;
     this.recordingEndpoint = recordingEndpoint;
+    this.storageEngine = storageEngine;
   }
   json() {
     return {
@@ -41,6 +43,7 @@ export class ConfigConstructorModel {
       quality: this.quality,
       fps: this.fps,
       recordingEndpoint: this.recordingEndpoint,
+      storageEngine: this.storageEngine,
     };
   }
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "iidrak-analytics-react",
-  "version": "1.3.0",
+  "version": "1.5.1",
   "description": "react native client for metastreamio",
   "peerDependencies": {
     "react-native-mmkv": ">=4.0.0",
     "react-native-nitro-modules": ">=0.30.0",
+    "@react-native-async-storage/async-storage": ">=1.17.0",
     "@react-native-community/netinfo": ">=11.5.2",
     "react": ">=18.0.0",
     "react-native": ">=0.70.0",
@@ -12,6 +13,17 @@
     "react-native-view-shot": ">=3.0.0",
     "react-native-safe-area-context": ">=4.0.0"
   },
+  "peerDependenciesMeta": {
+    "react-native-mmkv": {
+      "optional": true
+    },
+    "react-native-nitro-modules": {
+      "optional": true
+    },
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "string-format": "^0.5.0"
   },