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

package/android/src/main/java/com/scalebun/core/performance/AppStartCollector.kt

@@ -6,6 +6,7 @@ import android.os.Build
 import android.os.Bundle
 import android.os.Process
 import android.os.SystemClock
+import android.util.Log
 
 /**
  * Captures app start timing using Android-native hooks.
@@ -23,10 +24,24 @@ import android.os.SystemClock
  */
 class AppStartCollector(private val app: Application) {
 
+    companion object {
+        private const val TAG = "ScaleBunPerformance"
+        /** Ignore an inferred cold-start proxy longer than this (stale/warm process). */
+        private const val MAX_INFERRED_DURATION_MS = 60_000L
+    }
+
     data class AppStartInfo(
         val launchType: String,        // "cold" | "warm"
         val durationMs: Long,
-        val breakdown: Breakdown?
+        val breakdown: Breakdown?,
+        /**
+         * true when the value was NOT captured from Activity lifecycle callbacks
+         * but inferred from process-start → query time. Happens on the common RN
+         * path where the SDK's native init runs (JS-driven) only after the launch
+         * activity has already resumed, so onActivityResumed is never observed.
+         * Without this fallback getInfo() returns null and no app_launch is emitted.
+         */
+        val inferred: Boolean = false
     )
 
     data class Breakdown(
@@ -86,9 +101,11 @@ class AppStartCollector(private val app: Application) {
                         processStartMs = null,  // Already at process start
                         activityCreateMs = createDuration,
                         firstFrameMs = resumeDuration
-                    )
+                    ),
+                    inferred = false
                 )
 
+                Log.i(TAG, "app start captured from lifecycle: durationMs=$totalDuration")
                 callback?.invoke(info)
                 stop()
             }
@@ -113,20 +130,51 @@ class AppStartCollector(private val app: Application) {
     /** Check if app start has been captured */
     fun isCaptured(): Boolean = captured
 
-    /** Get the captured info for on-demand queries */
+    /**
+     * Get app start info for on-demand queries.
+     *
+     * Prefers the precise value captured from Activity lifecycle callbacks. When
+     * capture never happened — the common RN case, because native init is driven
+     * from JS and runs only AFTER the launch activity resumed — falls back to an
+     * inferred duration from process start to now. Returning null here (the old
+     * behaviour) is exactly what caused App start = 0: AppLaunchCollector.collect()
+     * bails on a null/invalid duration, so no app_launch event was ever emitted.
+     */
     fun getInfo(): AppStartInfo? {
-        if (!captured) return null
-        val totalDuration = activityResumeUptimeMs - processStartUptimeMs
+        if (captured) {
+            val totalDuration = activityResumeUptimeMs - processStartUptimeMs
+            return AppStartInfo(
+                launchType = "cold",
+                durationMs = totalDuration,
+                breakdown = Breakdown(
+                    processStartMs = null,
+                    activityCreateMs = if (activityCreateUptimeMs > 0)
+                        activityCreateUptimeMs - processStartUptimeMs else null,
+                    firstFrameMs = if (activityCreateUptimeMs > 0)
+                        activityResumeUptimeMs - activityCreateUptimeMs else null
+                ),
+                inferred = false
+            )
+        }
+
+        // Fallback: infer from process start → now. Guards against a bad clock
+        // (non-positive) and against a long-lived process where this proxy would
+        // be meaningless (e.g. queried minutes after a warm start).
+        if (processStartUptimeMs <= 0) {
+            Log.w(TAG, "app start not captured and no process-start clock — returning null")
+            return null
+        }
+        val inferredDuration = SystemClock.uptimeMillis() - processStartUptimeMs
+        if (inferredDuration <= 0 || inferredDuration > MAX_INFERRED_DURATION_MS) {
+            Log.w(TAG, "app start not captured; inferred duration out of range ($inferredDuration ms) — returning null")
+            return null
+        }
+        Log.i(TAG, "app start not captured from lifecycle; inferred durationMs=$inferredDuration")
         return AppStartInfo(
             launchType = "cold",
-            durationMs = totalDuration,
-            breakdown = Breakdown(
-                processStartMs = null,
-                activityCreateMs = if (activityCreateUptimeMs > 0)
-                    activityCreateUptimeMs - processStartUptimeMs else null,
-                firstFrameMs = if (activityCreateUptimeMs > 0)
-                    activityResumeUptimeMs - activityCreateUptimeMs else null
-            )
+            durationMs = inferredDuration,
+            breakdown = null,
+            inferred = true
         )
     }
 }

package/android/src/main/java/com/scalebun/rn/performance/PerformanceModule.kt

@@ -1,6 +1,7 @@
 package com.scalebun.rn.performance
 
 import android.app.Application
+import android.util.Log
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.scalebun.core.performance.AppStartCollector
@@ -33,6 +34,7 @@ class PerformanceModule(reactContext: ReactApplicationContext) : PerformanceSpec
 
     companion object {
         const val NAME = "ScaleBunPerformance"
+        private const val TAG = "ScaleBunPerformance"
     }
 
     override fun getName(): String = NAME
@@ -65,6 +67,7 @@ class PerformanceModule(reactContext: ReactApplicationContext) : PerformanceSpec
                 putDouble("maxFrameTimeMs", snapshot.maxFrameTimeMs)
                 putDouble("windowMs", snapshot.windowMs.toDouble())
             }
+            Log.i(TAG, "emit FrameMetrics: totalFrames=${snapshot.totalFrames} dropped=${snapshot.droppedFrames}")
             emit("ScaleBunPerformance_FrameMetrics", params)
         }
 
@@ -73,6 +76,7 @@ class PerformanceModule(reactContext: ReactApplicationContext) : PerformanceSpec
                 putDouble("durationMs", info.durationMs.toDouble())
                 putDouble("timestamp", info.timestamp.toDouble())
             }
+            Log.i(TAG, "emit UiHang: durationMs=${info.durationMs}")
             emit("ScaleBunPerformance_UiHang", params)
         }
     }
@@ -83,12 +87,14 @@ class PerformanceModule(reactContext: ReactApplicationContext) : PerformanceSpec
     override fun initialize(promise: Promise) {
         try {
             if (core?.isInitialized == true) {
+                Log.i(TAG, "initialize() — already initialized, no-op")
                 promise.resolve(true)
                 return
             }
 
             val app = reactApplicationContext.applicationContext as? Application
             if (app == null) {
+                Log.w(TAG, "initialize() — Application context not available")
                 promise.reject("PERF_INIT_ERROR", "Application context not available")
                 return
             }
@@ -98,8 +104,10 @@ class PerformanceModule(reactContext: ReactApplicationContext) : PerformanceSpec
             performanceCore.initialize()
             core = performanceCore
 
+            Log.i(TAG, "initialize() — native performance core started")
             promise.resolve(true)
         } catch (e: Exception) {
+            Log.w(TAG, "initialize() — failed: ${e.message}")
             promise.reject("PERF_INIT_ERROR", e.message, e)
         }
     }
@@ -111,9 +119,11 @@ class PerformanceModule(reactContext: ReactApplicationContext) : PerformanceSpec
         try {
             val info = core?.getAppStartInfo()
             if (info != null) {
+                Log.i(TAG, "getAppStartInfo() — launchType=${info.launchType} durationMs=${info.durationMs} inferred=${info.inferred}")
                 val result = Arguments.createMap().apply {
                     putString("launchType", info.launchType)
                     putDouble("durationMs", info.durationMs.toDouble())
+                    putBoolean("inferred", info.inferred)
                     info.breakdown?.let { breakdown ->
                         val breakdownMap = Arguments.createMap().apply {
                             breakdown.processStartMs?.let { putDouble("processStartMs", it.toDouble()) }
@@ -125,6 +135,7 @@ class PerformanceModule(reactContext: ReactApplicationContext) : PerformanceSpec
                 }
                 promise.resolve(result)
             } else {
+                Log.w(TAG, "getAppStartInfo() — no info available (core=${if (core == null) "null" else "present"})")
                 promise.resolve(null)
             }
         } catch (e: Exception) {

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;
         }
       }
     };
@@ -15663,12 +15749,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(() => {
       });
@@ -16235,19 +16332,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() {