@scalebun/react-native 1.2.3 → 1.3.1-beta.0

package/src/bootstrap/SDKBootstrapper.ts

@@ -38,6 +38,7 @@ import { createStorageBackend, MemoryBackend } from '../storage/StorageBackend';
 import { SessionManager } from '../features/session/SessionManager';
 import { nativeCapture } from '../features/session/nativeCapture';
 import { installAlertInstrumentation, uninstallAlertInstrumentation } from '../features/replay/integrations/alert/alertInstrumentation';
+import { installConsoleIntegration, uninstallConsoleIntegration } from '../features/replay/integrations/logs/consoleIntegration';
 import { BackendSessionAdapter } from '../features/session/BackendSessionAdapter';
 import { generateSessionId } from '../features/replay/core/ids/sessionId';
 import type { FeatureContext } from '../core/contracts/IFeature';
@@ -381,6 +382,16 @@ export class SDKBootstrapper {
                     });
                     sessionManager.setBackendTransport(backendAdapter);
 
+                    // Opt-in console → Logs lane. Armed here (not only in the desktop-debug
+                    // replay orchestrator) so a stock SaaS app can capture console.* without
+                    // pulling in the devTools bundle. Gated by clientKey (the backend transport
+                    // forwardToLogsLane needs is now set above) AND the explicit
+                    // captureConsoleLogs opt-in — console output can carry PII, so it stays off
+                    // unless the host asks for it. queueLog itself no-ops without a clientKey.
+                    if (this.config.clientKey && this.config.captureConsoleLogs) {
+                        installConsoleIntegration();
+                    }
+
                     // Cross-kill frame recovery: if a prior run was killed with
                     // unflushed frames, re-upload them linked to that PRIOR session
                     // before the new session takes over. Best-effort, independent of
@@ -608,6 +619,7 @@ export class SDKBootstrapper {
         this._deepLinkUnsubscribe?.();
         this._deepLinkUnsubscribe = null;
         uninstallAlertInstrumentation();
+        uninstallConsoleIntegration();
         this.featureRegistry.teardownAll();
     }
 }

package/src/core/config/schema.ts

@@ -170,6 +170,12 @@ const SHAPE: Record<string, Field> = {
         },
     },
     captureInteractionHeatmap: bool(true),
+    // Opt-in: intercept console.* and ship the lines to the Diagnose → Logs lane in SaaS
+    // mode. OFF by default — console output can carry PII/secrets and adds ingest volume,
+    // so capturing it is the host's explicit choice, not a silent default. When true and a
+    // clientKey is present, the bootstrapper arms the console integration (previously only
+    // reachable through the desktop-debug tooling, so stock SaaS apps captured nothing).
+    captureConsoleLogs: bool(false),
     ota: {
         kind: 'obj',
         opt: true,
@@ -346,6 +352,8 @@ export interface ScaleBunConfig {
         deltaKeyframeInterval?: number;
     };
     captureInteractionHeatmap: boolean;
+    /** Opt-in: capture console.* into the Logs lane in SaaS mode. Default false. */
+    captureConsoleLogs: boolean;
     ota?: {
         enabled: boolean;
         checkOnForeground: boolean;

package/src/features/replay/integrations/logs/consoleIntegration.ts

@@ -25,6 +25,22 @@ const CONSOLE_LEVEL: Record<string, string> = {
     debug: 'debug',
 };
 
+/**
+ * Prefixes that identify a log line as SDK-internal. These still print to the real
+ * console (developers may want to see them in dev), but they must NEVER be routed
+ * into the customer-facing logs lane or replay breadcrumbs — otherwise SDK self-noise
+ * (e.g. one [TapDiag] per tap, or internal [ScaleBun:*]/[perf.*] diagnostics) buries
+ * the customer's own logs in Diagnose → Logs. `[ReplaySdk]` is handled separately and
+ * suppressed entirely (it also trips the RN/Expo error overlay).
+ */
+const SDK_INTERNAL_LOG_PREFIXES = ['[TapDiag]', '[TapAccuracy]', '[ScaleBun', '[perf.'];
+
+/** True when a console line is an SDK-internal diagnostic that must not reach customer surfaces. */
+function isSdkInternalLog(firstArg: unknown): boolean {
+    return typeof firstArg === 'string'
+        && SDK_INTERNAL_LOG_PREFIXES.some(prefix => firstArg.startsWith(prefix));
+}
+
 /**
  * First producer into the logs lane: forward this console call to the backend logs
  * queue (source='console', platform='js'). Additive to the existing breadcrumb capture
@@ -76,6 +92,10 @@ export function installConsoleIntegration(): void {
             // Always call original for non-SDK logs
             original.apply(console, args);
 
+            // Print SDK-internal diagnostics to the console (dev visibility) but never
+            // forward them to the customer-facing logs lane / breadcrumbs.
+            if (isSdkInternalLog(firstArg)) return;
+
             if (_enabled) {
                 try {
                     const message = args.map(a => {

package/src/features/session/SessionManager.ts

@@ -858,8 +858,14 @@ export class SessionManager {
                         confidence: p.confidence ?? null,
                         source: p.source ?? null,
                     };
+                    // Dev-only diagnostic echo. Must NOT emit in release: the console
+                    // capture integration (captureConsoleLogs) would otherwise forward
+                    // one [TapDiag] line per tap into the customer-facing Logs lane and
+                    // bury their own logs. Sibling [TapAccuracy] log above is __DEV__-gated
+                    // for the same reason; the heatmap/replay data flows through the
+                    // interaction pipeline, not this echo, so gating it loses nothing.
                     // eslint-disable-next-line no-console
-                    console.log('[TapDiag]', JSON.stringify(diag));
+                    if (__DEV__) console.log('[TapDiag]', JSON.stringify(diag));
                 } catch { /* no-throw */ }
             }
 

package/src/public/ScaleBunFacade.ts

@@ -1264,8 +1264,26 @@ class ScaleBunFacade {
         });
     }
 
-    /** Log a message (convenience wrapper over track) */
+    /**
+     * Log a message. Delivered to BOTH lanes:
+     *  - the Diagnose → Logs lane (tagged `source: 'sdk'`), so an explicit `log()` call shows
+     *    up where a developer looks for logs. The method name promised this, but it previously
+     *    only emitted a `$log` analytics EVENT and never reached the Logs page.
+     *  - the analytics `$log` event (unchanged), so anything already built on it keeps working.
+     * `queueLog` self-gates on `clientKey`, so the Logs-lane write is a no-op outside SaaS mode.
+     */
     public log(level: 'debug' | 'info' | 'warn' | 'error', message: string, data?: Record<string, unknown>) {
+        try {
+            const transport = SessionManager.getExistingInstance()?.getBackendTransport();
+            transport?.queueLog({
+                level,
+                message,
+                source: 'sdk',
+                platform: 'js',
+                timestamp: new Date().toISOString(),
+                ...(data ? { metadata: data } : {}),
+            });
+        } catch { /* no-throw: a logging call must never break the host app */ }
         return this.track('$log', { level, message, ...data });
     }
 

package/src/public/types.ts

@@ -110,6 +110,12 @@ export interface ScaleBunInitConfig {
     features?: ScaleBunFeatures;
     /** Performance pipeline activation flags (tiered, default-safe). */
     performance?: PerformanceFlags;
+    /**
+     * Capture `console.*` output into the Diagnose → Logs lane (SaaS mode). Default: **false**.
+     * Off by default because console output can carry PII/secrets and adds ingest volume.
+     * Requires a `clientKey`; no desktop-debug/devTools setup needed.
+     */
+    captureConsoleLogs?: boolean;
 }
 
 // ─── User Identity ──────────────────────────────────────────────────────────
@@ -316,6 +322,13 @@ export interface SimplifiedInitConfig {
     /** Performance pipeline activation flags (tiered, default-safe). */
     performance?: PerformanceFlags;
 
+    /**
+     * Capture `console.*` output into the Diagnose → Logs lane (SaaS mode). Default: **false**.
+     * Off by default because console output can carry PII/secrets and adds ingest volume —
+     * enable it deliberately. Requires a `clientKey`; no desktop-debug/devTools setup needed.
+     */
+    captureConsoleLogs?: boolean;
+
     // ─── Phase 1: Envelope event tracking (POST /v1/batch) ──────────────────
     /** Dashboard App ID. Required to enable the envelope event-tracking lane. */
     appId?: string;