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

package/src/features/performance/collectors/AppLaunchCollector.ts

@@ -13,6 +13,7 @@ import { getNativePerformanceModule } from '../getNativePerformanceModule';
 import type { AppLaunchEvent, PerfContext, LaunchType } from '../models';
 import { PERF_SCHEMA_VERSION } from '../models';
 import type { PerformanceConfig } from '../config';
+import { logger } from '../../../core/logger/internalLogger';
 
 export type LaunchEventCallback = (event: AppLaunchEvent) => void;
 
@@ -46,12 +47,21 @@ export class AppLaunchCollector {
 
         try {
             const perfModule = getNativePerformanceModule();
-            if (!perfModule?.getAppStartInfo) return;
+            if (!perfModule?.getAppStartInfo) {
+                // [perf.trace] diagnostic (warn so it survives the default release log level)
+                logger.warn('[perf.trace] AppLaunchCollector: native perf module unavailable — no app_launch');
+                return;
+            }
 
             // The moment we call the native bridge = JS is ready
             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 — no app_launch', {
+                    hasInfo: !!info, durationType: typeof info?.durationMs,
+                });
+                return;
+            }
 
             this.collected = true;
 
@@ -108,9 +118,13 @@ export class AppLaunchCollector {
                 phaseLabels: hasBreakdown ? phaseLabels : undefined,
             };
 
+            logger.warn('[perf.trace] AppLaunchCollector: app_launch built, invoking handler', {
+                durationMs: event.durationMs, launchType: event.launchType,
+            });
             this.onLaunch(event);
-        } catch {
+        } catch (e) {
             // No-throw — native module may not be available
+            logger.warn('[perf.trace] AppLaunchCollector: collect() threw', { message: (e as Error)?.message });
         }
     }
 }

package/src/features/session/BackendSessionAdapter.ts

@@ -717,8 +717,17 @@ export class BackendSessionAdapter implements SessionTransport {
         type: string; screenName?: string; duration?: number; value?: number;
         metadata?: Record<string, unknown>;
     }): void {
-        if (this.destroyed || !this.config.clientKey) return;
+        if (this.destroyed || !this.config.clientKey) {
+            logger.warn('[perf.queue] dropped — no clientKey or adapter destroyed', {
+                type: data.type, destroyed: this.destroyed, hasClientKey: !!this.config.clientKey,
+            });
+            return;
+        }
         this.pendingPerformanceMetrics.push({ ...data, clientId: this._clientId(), timestamp: new Date().toISOString() });
+        // [perf.trace] diagnostic at warn so it survives the default release log level.
+        logger.warn('[perf.trace] queue enqueued performance metric', {
+            type: data.type, pending: this.pendingPerformanceMetrics.length,
+        });
         if (this.pendingPerformanceMetrics.length >= 20) {
             this._flushPerformance().catch(() => {});
         }
@@ -1405,14 +1414,32 @@ export class BackendSessionAdapter implements SessionTransport {
     }
 
     private async _flushPerformance(): Promise<void> {
-        if (this.pendingPerformanceMetrics.length === 0 || !this.currentSessionId || !this.config.clientKey) return;
+        if (this.pendingPerformanceMetrics.length === 0) return;
+        if (!this.currentSessionId || !this.config.clientKey) {
+            // [perf.trace] diagnostics below are warn-level so they survive the default release log level.
+            logger.warn('[perf.trace] flush waiting — 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 (!this._sessionRowReady()) { this.pendingPerformanceMetrics.unshift(...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 — 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);
         }
     }