@scalebun/react-native 1.2.0 → 1.2.2-beta.0

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;
     }
   }
 };
@@ -12462,12 +12548,23 @@ var BackendSessionAdapter = class _BackendSessionAdapter {
     this._triggerNativeFlush();
   }
   queuePerformanceMetric(data) {
-    if (this.destroyed || !this.config.clientKey) return;
+    if (this.destroyed || !this.config.clientKey) {
+      logger.warn("[perf.queue] dropped \u2014 no clientKey or adapter destroyed", {
+        type: data.type,
+        destroyed: this.destroyed,
+        hasClientKey: !!this.config.clientKey
+      });
+      return;
+    }
     this.pendingPerformanceMetrics.push({
       ...data,
       clientId: this._clientId(),
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
+    logger.debug("[perf.queue] enqueued performance metric", {
+      type: data.type,
+      pending: this.pendingPerformanceMetrics.length
+    });
     if (this.pendingPerformanceMetrics.length >= 20) {
       this._flushPerformance().catch(() => {
       });
@@ -13034,19 +13131,43 @@ var BackendSessionAdapter = class _BackendSessionAdapter {
     }
   }
   async _flushPerformance() {
-    if (this.pendingPerformanceMetrics.length === 0 || !this.currentSessionId || !this.config.clientKey) return;
+    if (this.pendingPerformanceMetrics.length === 0) return;
+    if (!this.currentSessionId || !this.config.clientKey) {
+      logger.debug("[perf.flush] waiting \u2014 not deliverable yet", {
+        pending: this.pendingPerformanceMetrics.length,
+        hasSession: !!this.currentSessionId,
+        hasClientKey: !!this.config.clientKey
+      });
+      return;
+    }
     const batch = this.pendingPerformanceMetrics.splice(0, 50);
     try {
-      if (await this._enqueueNative("performance", batch)) return;
+      if (await this._enqueueNative("performance", batch)) {
+        logger.debug("[perf.flush] handed to native outbox", {
+          count: batch.length
+        });
+        return;
+      }
       if (!this._sessionRowReady()) {
+        logger.debug("[perf.flush] session row not ready \u2014 re-buffering", {
+          count: batch.length
+        });
         this.pendingPerformanceMetrics.unshift(...batch);
         return;
       }
       await this._post(ENDPOINTS.INGESTION_PERFORMANCE(this.currentSessionId), {
         metrics: batch
       });
+      logger.info("[perf.flush] POST performance metrics ok", {
+        count: batch.length
+      });
     } catch (err) {
-      if (!_BackendSessionAdapter._isPermanentHttpError(err)) this.pendingPerformanceMetrics.unshift(...batch);
+      const permanent = _BackendSessionAdapter._isPermanentHttpError(err);
+      logger.warn("[perf.flush] POST performance metrics failed", {
+        count: batch.length,
+        permanent
+      });
+      if (!permanent) this.pendingPerformanceMetrics.unshift(...batch);
     }
   }
   async _flushLogs() {