@scalebun/react-native 1.2.0 → 1.2.1

package/dist/scalebun.slim.js

@@ -11423,7 +11423,31 @@ var PerformanceFeature = class _PerformanceFeature {
   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);
@@ -11558,6 +11582,9 @@ var PerformanceFeature = class _PerformanceFeature {
       clearTimeout(this._captureTimer);
       this._captureTimer = null;
     }
+    this._clearBackendDrainTimer();
+    this._backendDrainAttempts = 0;
+    this._pendingBackendMetrics = [];
   }
   get isActive() {
     return this.active;
@@ -11741,24 +11768,83 @@ var PerformanceFeature = class _PerformanceFeature {
   // ─── 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;
     }
   }
 };