@scalebun/react-native 1.2.1 → 1.2.2-beta.1

package/dist/scalebun.slim.js

@@ -10609,6 +10609,7 @@ function getNativePerformanceModule() {
 }
 
 // lib/module/features/performance/collectors/AppLaunchCollector.js
+init_internalLogger();
 var JS_IMPORT_TIME = Date.now();
 var AppLaunchCollector = class {
   collected = false;
@@ -10626,10 +10627,19 @@ var AppLaunchCollector = class {
     if (this.collected || !this.config.appLaunch) return;
     try {
       const perfModule = getNativePerformanceModule();
-      if (!perfModule?.getAppStartInfo) return;
+      if (!perfModule?.getAppStartInfo) {
+        logger.warn("[perf.trace] AppLaunchCollector: native perf module unavailable \u2014 no app_launch");
+        return;
+      }
       const jsReadyTimestamp = Date.now();
       const info = await perfModule.getAppStartInfo();
-      if (!info || typeof info.durationMs !== "number") return;
+      if (!info || typeof info.durationMs !== "number") {
+        logger.warn("[perf.trace] AppLaunchCollector: getAppStartInfo returned no usable duration \u2014 no app_launch", {
+          hasInfo: !!info,
+          durationType: typeof info?.durationMs
+        });
+        return;
+      }
       this.collected = true;
       const breakdown = {};
       const phaseLabels = {};
@@ -10674,8 +10684,15 @@ var AppLaunchCollector = class {
         breakdown: hasBreakdown ? breakdown : void 0,
         phaseLabels: hasBreakdown ? phaseLabels : void 0
       };
+      logger.warn("[perf.trace] AppLaunchCollector: app_launch built, invoking handler", {
+        durationMs: event.durationMs,
+        launchType: event.launchType
+      });
       this.onLaunch(event);
-    } catch {
+    } catch (e) {
+      logger.warn("[perf.trace] AppLaunchCollector: collect() threw", {
+        message: e?.message
+      });
     }
   }
 };
@@ -11395,6 +11412,7 @@ var PerformanceTransport = class {
 
 // lib/module/features/performance/PerformanceFeature.js
 init_SessionManager();
+init_internalLogger();
 var PerformanceFeature = class _PerformanceFeature {
   name = "performance";
   active = false;
@@ -11795,7 +11813,14 @@ var PerformanceFeature = class _PerformanceFeature {
    * flushes the backlog in the order the metrics were produced.
    */
   _forwardMetricToBackend(metric) {
-    const backendTransport = SessionManager.getExistingInstance()?.getBackendTransport();
+    const sm = SessionManager.getExistingInstance();
+    const backendTransport = sm?.getBackendTransport();
+    logger.warn("[perf.trace] forwardMetricToBackend", {
+      type: metric.type,
+      hasSessionManager: !!sm,
+      hasBackendTransport: !!backendTransport,
+      buffered: this._pendingBackendMetrics.length
+    });
     if (backendTransport) {
       this._drainPendingBackendMetrics(backendTransport);
       backendTransport.queuePerformanceMetric(metric);
@@ -11815,6 +11840,9 @@ var PerformanceFeature = class _PerformanceFeature {
     for (const metric of buffered) {
       backendTransport.queuePerformanceMetric(metric);
     }
+    logger.warn("[perf.trace] drained buffered metrics to backend", {
+      count: buffered.length
+    });
     this._clearBackendDrainTimer();
     this._backendDrainAttempts = 0;
   }
@@ -11827,7 +11855,13 @@ var PerformanceFeature = class _PerformanceFeature {
    */
   _scheduleBackendDrain() {
     if (this._backendDrainTimer) return;
-    if (this._backendDrainAttempts >= _PerformanceFeature.BACKEND_DRAIN_MAX_ATTEMPTS) return;
+    if (this._backendDrainAttempts >= _PerformanceFeature.BACKEND_DRAIN_MAX_ATTEMPTS) {
+      logger.warn("[perf.trace] drain gave up \u2014 buffered metrics never reached the backend", {
+        attempts: this._backendDrainAttempts,
+        dropped: this._pendingBackendMetrics.length
+      });
+      return;
+    }
     const delays = _PerformanceFeature.BACKEND_DRAIN_DELAYS;
     const delay = delays[Math.min(this._backendDrainAttempts, delays.length - 1)];
     this._backendDrainAttempts++;
@@ -12548,12 +12582,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.warn("[perf.trace] queue enqueued performance metric", {
+      type: data.type,
+      pending: this.pendingPerformanceMetrics.length
+    });
     if (this.pendingPerformanceMetrics.length >= 20) {
       this._flushPerformance().catch(() => {
       });
@@ -13120,19 +13165,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.warn("[perf.trace] 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.warn("[perf.trace] flush handed to native outbox", {
+          count: batch.length
+        });
+        return;
+      }
       if (!this._sessionRowReady()) {
+        logger.warn("[perf.trace] 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.warn("[perf.trace] 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() {