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

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

@@ -7480,6 +7480,7 @@ var init_AppLaunchCollector = __esm({
     "use strict";
     init_getNativePerformanceModule();
     init_models();
+    init_internalLogger();
     JS_IMPORT_TIME = Date.now();
     AppLaunchCollector = class {
       collected = false;
@@ -7497,10 +7498,19 @@ var init_AppLaunchCollector = __esm({
         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 = {};
@@ -7545,8 +7555,15 @@ var init_AppLaunchCollector = __esm({
             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
+          });
         }
       }
     };
@@ -8341,6 +8358,7 @@ var init_PerformanceFeature = __esm({
     init_PerformanceTransport();
     init_MetricsEngine();
     init_SessionManager();
+    init_internalLogger();
     PerformanceFeature = class _PerformanceFeature {
       name = "performance";
       active = false;
@@ -8741,7 +8759,14 @@ var init_PerformanceFeature = __esm({
        * 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);
@@ -8761,6 +8786,9 @@ var init_PerformanceFeature = __esm({
         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;
       }
@@ -8773,7 +8801,13 @@ var init_PerformanceFeature = __esm({
        */
       _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++;
@@ -15749,12 +15783,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(() => {
       });
@@ -16321,19 +16366,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() {