@scalebun/react-native 1.2.0 → 1.2.1

package/dist/scalebun.full.js

@@ -8369,7 +8369,31 @@ var init_PerformanceFeature = __esm({
       static CAPTURE_MAX_RETRIES = 3;
       /** Delay schedule for each attempt (ms) — escalating to let views settle */
       static CAPTURE_DELAYS = [300, 600, 1200];
-      // Track event function from SDK pipeline
+      // ─── Early-metric buffering (backend) ───────────────────────────────
+      //
+      // Performance metrics reach the cloud via the SessionManager's backend
+      // transport. But the first metrics — most importantly app_launch — fire
+      // during PerformanceFeature.initialize() (appLaunchCollector.collect()),
+      // which runs from featureRegistry.initializeAll() BEFORE the bootstrap
+      // attaches the backend transport (SDKBootstrapper). In that window
+      // getBackendTransport() is null, so without buffering the metric is sent
+      // only to the desktop debugger and silently dropped from the cloud
+      // ("App start = 0" in Insights). We buffer such metrics locally and drain
+      // them the moment the transport appears (via subsequent events or a
+      // bounded retry). The backend adapter itself buffers again until the
+      // session row is ready, so ordering across the session boundary is safe.
+      /** Metrics captured before the backend transport was available. */
+      _pendingBackendMetrics = [];
+      /** Retry timer that drains the buffer once the transport attaches. */
+      _backendDrainTimer = null;
+      /** Number of drain attempts made for the current buffered batch. */
+      _backendDrainAttempts = 0;
+      /** Hard cap on buffered metrics — bounds memory if a transport never attaches (non-SaaS). */
+      static BACKEND_BUFFER_MAX = 64;
+      /** Max drain retries before giving up (non-SaaS mode never attaches a transport). */
+      static BACKEND_DRAIN_MAX_ATTEMPTS = 6;
+      /** Escalating retry delays (ms); last value repeats. Covers the startup attach race. */
+      static BACKEND_DRAIN_DELAYS = [250, 500, 1e3, 2e3, 4e3];
       constructor(config) {
         this.config = mergePerformanceConfig(config);
         this.transport = new PerformanceTransport(this.config);
@@ -8504,6 +8528,9 @@ var init_PerformanceFeature = __esm({
           clearTimeout(this._captureTimer);
           this._captureTimer = null;
         }
+        this._clearBackendDrainTimer();
+        this._backendDrainAttempts = 0;
+        this._pendingBackendMetrics = [];
       }
       get isActive() {
         return this.active;
@@ -8687,24 +8714,83 @@ var init_PerformanceFeature = __esm({
       // ─── Internal ───────────────────────────────────────────────────────
       _handleEvent(event) {
         this.transport.sendEvent(event);
+        this._forwardMetricToBackend(this._toBackendMetric(event));
+      }
+      /** Map a raw perf event onto the backend metric envelope. */
+      _toBackendMetric(event) {
+        const e = event;
+        const metadata = {
+          id: event.id
+        };
+        if (event.type === "app_launch") {
+          if (e.launchType) metadata.launchType = e.launchType;
+          if (e.breakdown) metadata.breakdown = e.breakdown;
+          if (e.phaseLabels) metadata.phaseLabels = e.phaseLabels;
+        }
+        return {
+          type: event.type,
+          screenName: e.screenName ?? e.context?.screenKey,
+          duration: e.durationMs,
+          value: e.estimatedFps ?? e.value,
+          metadata
+        };
+      }
+      /**
+       * Hand a metric to the backend transport, or buffer it until one attaches.
+       * Every call first drains anything buffered, so a late-arriving transport
+       * flushes the backlog in the order the metrics were produced.
+       */
+      _forwardMetricToBackend(metric) {
         const backendTransport = SessionManager.getExistingInstance()?.getBackendTransport();
         if (backendTransport) {
-          const e = event;
-          const metadata = {
-            id: event.id
-          };
-          if (event.type === "app_launch") {
-            if (e.launchType) metadata.launchType = e.launchType;
-            if (e.breakdown) metadata.breakdown = e.breakdown;
-            if (e.phaseLabels) metadata.phaseLabels = e.phaseLabels;
-          }
-          backendTransport.queuePerformanceMetric({
-            type: event.type,
-            screenName: e.screenName ?? e.context?.screenKey,
-            duration: e.durationMs,
-            value: e.estimatedFps ?? e.value,
-            metadata
-          });
+          this._drainPendingBackendMetrics(backendTransport);
+          backendTransport.queuePerformanceMetric(metric);
+          return;
+        }
+        this._pendingBackendMetrics.push(metric);
+        if (this._pendingBackendMetrics.length > _PerformanceFeature.BACKEND_BUFFER_MAX) {
+          this._pendingBackendMetrics.shift();
+        }
+        this._scheduleBackendDrain();
+      }
+      /** Flush all buffered metrics into the transport, preserving order. */
+      _drainPendingBackendMetrics(backendTransport) {
+        if (this._pendingBackendMetrics.length === 0) return;
+        const buffered = this._pendingBackendMetrics;
+        this._pendingBackendMetrics = [];
+        for (const metric of buffered) {
+          backendTransport.queuePerformanceMetric(metric);
+        }
+        this._clearBackendDrainTimer();
+        this._backendDrainAttempts = 0;
+      }
+      /**
+       * Poll for the backend transport a bounded number of times so the sole
+       * early metric (app_launch) still reaches the cloud even when no later
+       * event arrives to trigger a drain. Gives up after BACKEND_DRAIN_MAX_ATTEMPTS
+       * (non-SaaS mode never attaches a transport — the desktop path already has
+       * the data), leaving the bounded buffer to be GC'd on teardown.
+       */
+      _scheduleBackendDrain() {
+        if (this._backendDrainTimer) return;
+        if (this._backendDrainAttempts >= _PerformanceFeature.BACKEND_DRAIN_MAX_ATTEMPTS) return;
+        const delays = _PerformanceFeature.BACKEND_DRAIN_DELAYS;
+        const delay = delays[Math.min(this._backendDrainAttempts, delays.length - 1)];
+        this._backendDrainAttempts++;
+        this._backendDrainTimer = setTimeout(() => {
+          this._backendDrainTimer = null;
+          const backendTransport = SessionManager.getExistingInstance()?.getBackendTransport();
+          if (backendTransport) {
+            this._drainPendingBackendMetrics(backendTransport);
+          } else if (this._pendingBackendMetrics.length > 0) {
+            this._scheduleBackendDrain();
+          }
+        }, delay);
+      }
+      _clearBackendDrainTimer() {
+        if (this._backendDrainTimer) {
+          clearTimeout(this._backendDrainTimer);
+          this._backendDrainTimer = null;
         }
       }
     };