@grafana/faro-react-native 1.0.0-alpha.1 → 1.0.0

package/dist/types/instrumentations/session/sessionManager/index.d.ts

@@ -1,5 +1,5 @@
 export { getSessionManagerByConfig } from './getSessionManagerByConfig';
-export { PersistentSessionsManager } from './PersistentSessionsManager';
+export { MmkvPersistentSessionsManager } from './MmkvPersistentSessionsManager';
 export { isSampled } from './sampling';
 export * from './sessionConstants';
 export * from './sessionManagerUtils';

package/dist/types/instrumentations/session/sessionManager/types.d.ts

@@ -1,5 +1,5 @@
 import type { MetaSession } from '@grafana/faro-core';
-import type { PersistentSessionsManager } from './PersistentSessionsManager';
+import type { MmkvPersistentSessionsManager } from './MmkvPersistentSessionsManager';
 import type { VolatileSessionsManager } from './VolatileSessionManager';
 export interface FaroUserSession {
     sessionId: string;
@@ -8,4 +8,4 @@ export interface FaroUserSession {
     isSampled: boolean;
     sessionMeta?: MetaSession;
 }
-export type SessionManager = typeof VolatileSessionsManager | typeof PersistentSessionsManager;
+export type SessionManager = typeof VolatileSessionsManager | typeof MmkvPersistentSessionsManager;

package/dist/types/instrumentations/startup/index.d.ts

@@ -37,7 +37,7 @@ import type { StartupInstrumentationOptions } from './types';
 export declare class StartupInstrumentation extends BaseInstrumentation {
     private options;
     readonly name = "@grafana/faro-react-native:instrumentation-startup";
-    readonly version = "2.2.3";
+    readonly version = "2.3.1";
     /** 0 = came from background (warm start eligible), null = never backgrounded */
     private warmStartTimestamp;
     private appStateSubscription;

package/dist/types/instrumentations/userActions/index.d.ts

@@ -24,7 +24,7 @@ import { BaseInstrumentation } from '@grafana/faro-core';
  */
 export declare class UserActionInstrumentation extends BaseInstrumentation {
     readonly name = "@grafana/faro-react-native:instrumentation-user-action";
-    readonly version = "2.2.3";
+    readonly version = "2.3.1";
     private _userActionSub?;
     initialize(): void;
     /**

package/dist/types/instrumentations/view/index.d.ts

@@ -9,7 +9,7 @@ import { BaseInstrumentation } from '@grafana/faro-core';
  */
 export declare class ViewInstrumentation extends BaseInstrumentation {
     readonly name = "@grafana/faro-react-native:instrumentation-view";
-    readonly version = "2.2.3";
+    readonly version = "2.3.1";
     private notifiedView;
     private metaUnsubscribe;
     private sendViewChangedEvent;

package/dist/types/instrumentations/xhr/index.d.ts

@@ -7,7 +7,7 @@ import { BaseInstrumentation } from '@grafana/faro-core';
  */
 export declare class XHRInstrumentation extends BaseInstrumentation {
     readonly name = "@grafana/faro-react-native:instrumentation-xhr";
-    readonly version = "2.2.3";
+    readonly version = "2.3.1";
     private originalOpen?;
     private originalSend?;
     private ignoredUrls;

package/dist/types/internalLogger/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Internal logger levels - copied from @grafana/faro-core to avoid bundling web code
+ * Keep in sync with @grafana/faro-core's InternalLoggerLevel
+ */
+export declare enum InternalLoggerLevel {
+    OFF = 0,
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    VERBOSE = 4
+}
+/**
+ * Log levels for console/logging - copied from @grafana/faro-core to avoid bundling web code
+ * Keep in sync with @grafana/faro-core's LogLevel
+ */
+export declare enum LogLevel {
+    TRACE = "trace",
+    DEBUG = "debug",
+    INFO = "info",
+    LOG = "log",
+    WARN = "warn",
+    ERROR = "error"
+}
+export declare const defaultLogLevel = LogLevel.LOG;
+export declare const allLogLevels: ReadonlyArray<Readonly<LogLevel>>;

package/dist/types/metas/sdk.d.ts

@@ -1,6 +1,8 @@
 import type { Meta, MetaItem } from '@grafana/faro-core';
 /**
- * SDK meta for React Native
- * Provides information about the Faro SDK and its integrations
+ * SDK meta for React Native.
+ * - `sdk.version`: `@grafana/faro-core` release (same as Faro Web SDK).
+ * - `sdk.name`: integration id (`faro-web` / `faro-react-native`).
+ * - `sdk.integrations`: published `@grafana/faro-react-native` npm name and semver for this build.
  */
 export declare const getSdkMeta: () => MetaItem<Pick<Meta, "sdk">>;

package/dist/types/testUtils/mockFaroReactNativeTracing.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Jest stub for optional peer `@grafana/faro-react-native-tracing`.
+ * Mapped via moduleNameMapper so tests run without installing the tracing workspace package.
+ */
+import { BaseInstrumentation } from '@grafana/faro-core';
+export declare class TracingInstrumentation extends BaseInstrumentation {
+    readonly name = "@grafana/faro-react-native-tracing";
+    readonly version = "2.3.1";
+    initialize(): void;
+}

package/dist/types/transports/console/transport.d.ts

@@ -4,7 +4,7 @@ import type { ConsoleTransportOptions } from './types';
 export declare class ConsoleTransport extends BaseTransport {
     private options;
     readonly name = "@grafana/faro-react-native:transport-console";
-    readonly version = "2.2.3";
+    readonly version = "2.3.1";
     constructor(options?: ConsoleTransportOptions);
     send(item: TransportItem): void;
 }

package/dist/types/transports/fetch/transport.d.ts

@@ -4,7 +4,7 @@ import type { FetchTransportOptions } from './types';
 export declare class FetchTransport extends BaseTransport {
     private options;
     readonly name = "@grafana/faro-react-native:transport-fetch";
-    readonly version = "2.2.3";
+    readonly version = "2.3.1";
     promiseBuffer: PromiseBuffer<Response | void>;
     private readonly rateLimitBackoffMs;
     private readonly getNow;

package/dist/types/transports/offline/transport.d.ts

@@ -31,7 +31,7 @@ import type { OfflineTransportOptions } from './types';
  */
 export declare class OfflineTransport extends BaseTransport {
     readonly name = "@grafana/faro-react-native:transport-offline";
-    readonly version = "2.2.3";
+    readonly version = "2.3.1";
     private readonly cache;
     private readonly connectivityService;
     private readonly maxCacheDurationMs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grafana/faro-react-native",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0",
   "description": "Faro instrumentations, metas, transports for React Native.",
   "keywords": [
     "observability",
@@ -31,11 +31,13 @@
     "ios",
     "android",
     "FaroReactNative.podspec",
+    "react-native.config.js",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "start": "yarn watch",
+    "sync:package-meta": "node ./scripts/sync-faro-rn-package-meta.mjs",
     "build": "run-s 'build:*'",
     "build:compile": "run-p 'build:compile:*'",
     "build:compile:cjs": "tsc --build tsconfig.cjs.json",
@@ -50,7 +52,8 @@
     "quality:lint": "run-p 'quality:lint:eslint' 'quality:lint:prettier'",
     "quality:lint:eslint": "eslint --cache --cache-location ../../.cache/eslint/reactNative \"./**/*.{js,jsx,ts,tsx}\"",
     "quality:lint:prettier": "prettier --cache --cache-location=../../.cache/prettier/reactNative --ignore-path ../../.prettierignore -c \"./**/*.{js,jsx,ts,tsx,css,scss,md,yaml,yml,json}\"",
-    "quality:circular-deps": "madge --circular ."
+    "quality:circular-deps": "madge --circular .",
+    "version": "node ./scripts/sync-faro-rn-package-meta.mjs && git add src/generated/faroRNPackageMeta.ts"
   },
   "dependencies": {
     "@grafana/faro-core": "^2.2.3",
@@ -61,7 +64,8 @@
     "@grafana/faro-react-native-tracing": ">=1.0.0",
     "@react-navigation/native": ">=6.0.0",
     "react": ">=18.0.0",
-    "react-native": ">=0.70.0"
+    "react-native": ">=0.70.0",
+    "react-native-mmkv": ">=2.0.0"
   },
   "peerDependenciesMeta": {
     "@grafana/faro-react-native-tracing": {
@@ -69,15 +73,19 @@
     },
     "@react-navigation/native": {
       "optional": true
+    },
+    "react-native-mmkv": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@types/node": "24.10.1",
     "@types/react": "^19.1.1",
-    "@types/react-native": "^0.73.0"
+    "@types/react-native": "^0.73.0",
+    "react-native-mmkv": "^4.3.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "486ee5d65eb1e274a7e207e0c9c04cccffe98c2e"
+  "gitHead": "00172e294e05bcf2faa2193d01aabc43c3cc8134"
 }

package/react-native.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      ios: {},
+      android: {},
+    },
+  },
+};

package/src/config/getRNInstrumentations.test.ts

@@ -1,16 +1,3 @@
-/** Keeps tests working without a workspace devDependency (avoids npm/Lerna cycle: tracing → react-native → tracing). */
-jest.mock('@grafana/faro-react-native-tracing', () => {
-  const { BaseInstrumentation, VERSION } = require('@grafana/faro-core');
-
-  class TracingInstrumentation extends BaseInstrumentation {
-    readonly name = '@grafana/faro-react-native-tracing';
-    readonly version = VERSION;
-    initialize(): void {}
-  }
-
-  return { TracingInstrumentation };
-});
-
 import { Platform } from 'react-native';
 
 import { TracingInstrumentation } from '@grafana/faro-react-native-tracing';

package/src/config/getRNInstrumentations.ts

@@ -114,13 +114,15 @@ export function getRNInstrumentations(config: Partial<ReactNativeConfig> = {}):
     }
   }
 
-  // Performance vitals (CPU/memory)
-  const perfInstrumentation = new PerformanceInstrumentation({
-    memoryUsageVitals,
-    cpuUsageVitals,
-    fetchVitalsInterval,
-  });
-  instrumentations.push(perfInstrumentation);
+  // Performance vitals (CPU/memory) - only add if at least one metric is enabled
+  if (cpuUsageVitals || memoryUsageVitals) {
+    const perfInstrumentation = new PerformanceInstrumentation({
+      memoryUsageVitals,
+      cpuUsageVitals,
+      fetchVitalsInterval,
+    });
+    instrumentations.push(perfInstrumentation);
+  }
 
   // Startup tracking - always enabled
   instrumentations.push(new StartupInstrumentation());

package/src/config/makeRNConfig.test.ts

@@ -1,5 +1,6 @@
 import { BaseInstrumentation, VERSION } from '@grafana/faro-core';
 
+import { minimalSessionDeviceAttributes } from '../instrumentations/session/sessionAttributes';
 import { defaultSessionTrackingConfig } from '../instrumentations/session/sessionManager/sessionConstants';
 import { ConsoleTransport } from '../transports/console';
 import { FetchTransport } from '../transports/fetch';
@@ -114,4 +115,16 @@ describe('makeRNConfig', () => {
     expect(minimal.instrumentations?.length).toBe(direct.length);
     expect(minimal.instrumentations?.map((i) => i.name)).toEqual(direct.map((i) => i.name));
   });
+
+  it('passes preloaded session device attributes to core config when provided as second argument', () => {
+    const preloaded = minimalSessionDeviceAttributes();
+    preloaded.device_id = 'test-preloaded-id';
+    const cfg = makeRNConfig({ ...base }, preloaded);
+    expect(
+      (cfg as { preloadedSessionDeviceAttributes?: { device_id: string } }).preloadedSessionDeviceAttributes
+    ).toBeDefined();
+    expect(
+      (cfg as { preloadedSessionDeviceAttributes?: { device_id: string } }).preloadedSessionDeviceAttributes?.device_id
+    ).toBe('test-preloaded-id');
+  });
 });

package/src/config/makeRNConfig.ts

@@ -1,8 +1,10 @@
-import { defaultGlobalObjectKey, defaultUnpatchedConsole, InternalLoggerLevel, LogLevel } from '@grafana/faro-core';
+import { defaultGlobalObjectKey, defaultUnpatchedConsole } from '@grafana/faro-core';
 import type { Config } from '@grafana/faro-core';
 
 import { getStackFramesFromError } from '../instrumentations/errors/stackTraceParser';
+import type { SessionAttributes } from '../instrumentations/session/sessionAttributes';
 import { defaultSessionTrackingConfig } from '../instrumentations/session/sessionManager/sessionConstants';
+import { InternalLoggerLevel, LogLevel } from '../internalLogger';
 import { getPageMeta } from '../metas/page';
 import { getScreenMeta } from '../metas/screen';
 import { getSdkMeta } from '../metas/sdk';
@@ -11,7 +13,7 @@ import { FetchTransport } from '../transports/fetch';
 import { OfflineTransport } from '../transports/offline';
 
 import { getRNInstrumentations } from './getRNInstrumentations';
-import type { ReactNativeConfig, ReactNativeSessionTrackingConfig } from './types';
+import type { ReactNativeConfig, ReactNativeFullConfig } from './types';
 
 const DEFAULT_OFFLINE_CACHE_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
 
@@ -72,8 +74,13 @@ const parseStacktrace: Config['parseStacktrace'] = (err) => ({
  *
  * Based on flags, builds instrumentations and transports automatically.
  * Client just enables what they need; makeRNConfig does the rest.
+ *
+ * @param preloadedSessionDeviceAttributes Device/session fields for session meta (passed from async `initializeFaro`).
  */
-export function makeRNConfig(config: ReactNativeConfig): Config {
+export function makeRNConfig(
+  config: ReactNativeConfig,
+  preloadedSessionDeviceAttributes?: SessionAttributes
+): ReactNativeFullConfig {
   const defaultMetas = [getSdkMeta(), getPageMeta(), getScreenMeta()];
   const customMetas = config.metas ?? [];
   const transports = buildTransports(config);
@@ -81,6 +88,9 @@ export function makeRNConfig(config: ReactNativeConfig): Config {
 
   return {
     app: config.app,
+    ...(preloadedSessionDeviceAttributes != null && {
+      preloadedSessionDeviceAttributes,
+    }),
     dedupe: config.dedupe ?? true,
     globalObjectKey: config.globalObjectKey ?? defaultGlobalObjectKey,
     internalLoggerLevel: config.internalLoggerLevel ?? InternalLoggerLevel.ERROR,
@@ -97,7 +107,7 @@ export function makeRNConfig(config: ReactNativeConfig): Config {
     sessionTracking: {
       ...defaultSessionTrackingConfig,
       ...config.sessionTracking,
-    } as ReactNativeSessionTrackingConfig,
+    },
     metas: [...defaultMetas, ...customMetas],
     instrumentations,
     transports,

package/src/config/types.ts

@@ -2,6 +2,7 @@ import type { Config } from '@grafana/faro-core';
 
 import type { ANRInstrumentationOptions } from '../instrumentations/anr';
 import type { FrameMonitoringOptions } from '../instrumentations/frameMonitoring';
+import type { SessionAttributes } from '../instrumentations/session/sessionAttributes';
 
 import type { Sampling } from './sampling';
 
@@ -9,6 +10,9 @@ import type { Sampling } from './sampling';
  * React Native session tracking config.
  * Extends Config['sessionTracking'] with sampling (Flutter-style) and RN-specific props.
  * Excludes samplingRate and sampler in favor of sampling.
+ *
+ * When `persistent` is true, sessions are stored with [react-native-mmkv](https://github.com/mrousavy/react-native-mmkv)
+ * (synchronous). Add `react-native-mmkv` to your app and rebuild native projects.
  */
 export type ReactNativeSessionTrackingConfig = Omit<
   NonNullable<Config['sessionTracking']>,
@@ -77,3 +81,11 @@ export type ReactNativeConfig = Partial<
   Omit<Config, 'sessionTracking' | 'consoleInstrumentation' | 'userActionsInstrumentation'>
 > &
   ReactNativeConfigOverrides;
+
+/**
+ * Internal full config returned by `makeRNConfig`.
+ * Extends faro-core `Config` with RN-specific fields that instrumentations need at init time.
+ */
+export type ReactNativeFullConfig = Config & {
+  preloadedSessionDeviceAttributes?: SessionAttributes;
+};

package/src/generated/faroRNPackageMeta.test.ts

@@ -0,0 +1,10 @@
+import packageJson from '../../package.json';
+
+import { FARO_REACT_NATIVE_NPM_NAME, FARO_REACT_NATIVE_NPM_VERSION } from './faroRNPackageMeta';
+
+describe('faroRNPackageMeta', () => {
+  it('should match package.json (run yarn sync:package-meta after manual version edits, or use lerna version)', () => {
+    expect(FARO_REACT_NATIVE_NPM_NAME).toBe(packageJson.name);
+    expect(FARO_REACT_NATIVE_NPM_VERSION).toBe(packageJson.version);
+  });
+});

package/src/generated/faroRNPackageMeta.ts

@@ -0,0 +1,5 @@
+/**
+ * NPM package identity for this build. Generated by scripts/sync-faro-rn-package-meta.mjs - do not edit.
+ */
+export const FARO_REACT_NATIVE_NPM_NAME = '@grafana/faro-react-native' as const;
+export const FARO_REACT_NATIVE_NPM_VERSION = '1.0.0' as const;

package/src/index.ts

@@ -19,6 +19,12 @@ export { ErrorMechanism, ErrorsInstrumentation } from './instrumentations/errors
 export type { ErrorMechanismType, ErrorsInstrumentationOptions } from './instrumentations/errors';
 export { ConsoleInstrumentation } from './instrumentations/console';
 export { SessionInstrumentation } from './instrumentations/session';
+export {
+  getSessionAttributes,
+  loadSessionDeviceAttributesForInit,
+  minimalSessionDeviceAttributes,
+} from './instrumentations/session/sessionAttributes';
+export type { SessionAttributes } from './instrumentations/session/sessionAttributes';
 export { ViewInstrumentation } from './instrumentations/view';
 export { AppStateInstrumentation } from './instrumentations/appState';
 export { UserActionInstrumentation } from './instrumentations/userActions';
@@ -110,5 +116,5 @@ export type {
   PushMeasurementOptions,
 } from '@grafana/faro-core';
 
-// Export LogLevel enum (not just the type)
-export { LogLevel } from '@grafana/faro-core';
+// Export LogLevel and InternalLoggerLevel from our local copy (avoid bundling faro-core's web code)
+export { LogLevel, InternalLoggerLevel, allLogLevels, defaultLogLevel } from './internalLogger';

package/src/initialize.test.ts

@@ -0,0 +1,126 @@
+import { VERSION } from '@grafana/faro-core';
+import { mockConfig, MockTransport } from '@grafana/faro-test-utils';
+
+import packageJson from '../package.json';
+
+import { initializeFaro } from './initialize';
+import { SessionInstrumentation } from './instrumentations/session';
+import * as sessionAttributes from './instrumentations/session/sessionAttributes';
+
+describe('initializeFaro', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.clearAllTimers();
+    delete (global as any).faro;
+  });
+
+  it('should initialize Faro', async () => {
+    const transport = new MockTransport();
+    const faro = await initializeFaro(
+      mockConfig({
+        url: 'http://localhost:12345/collect',
+        transports: [transport],
+        instrumentations: [new SessionInstrumentation()],
+        sessionTracking: {
+          enabled: true,
+          persistent: false,
+        },
+      })
+    );
+
+    expect(faro).toBeDefined();
+    expect(faro.api).toBeDefined();
+    expect(faro.metas).toBeDefined();
+  });
+
+  it('should set session on init for volatile session tracking', async () => {
+    const transport = new MockTransport();
+    const faro = await initializeFaro(
+      mockConfig({
+        url: 'http://localhost:12345/collect',
+        transports: [transport],
+        instrumentations: [new SessionInstrumentation()],
+        sessionTracking: {
+          enabled: true,
+          persistent: false,
+        },
+      })
+    );
+
+    expect(faro).toBeDefined();
+    expect(faro.metas.value.session?.id).toBeDefined();
+  });
+
+  it('should attach session to telemetry events after init', async () => {
+    const transport = new MockTransport();
+    const faro = await initializeFaro(
+      mockConfig({
+        url: 'http://localhost:12345/collect',
+        transports: [transport],
+        instrumentations: [new SessionInstrumentation()],
+        sessionTracking: {
+          enabled: true,
+          persistent: false,
+        },
+      })
+    );
+
+    transport.items = [];
+    faro.api.pushEvent('test_event', { data: 'test' });
+
+    expect(transport.items).toHaveLength(1);
+    expect(transport.items[0].meta.session).toBeDefined();
+    expect(transport.items[0].meta.session?.id).toBeDefined();
+  });
+
+  it('should reject when url is missing', async () => {
+    await expect(
+      initializeFaro(
+        mockConfig({
+          // @ts-expect-error - testing missing url
+          url: undefined,
+          transports: [],
+        })
+      )
+    ).rejects.toThrow('url is required');
+  });
+
+  it('should await device attributes then merge preloaded session attributes', async () => {
+    const spy = jest.spyOn(sessionAttributes, 'loadSessionDeviceAttributesForInit').mockResolvedValue({
+      react_native_version: '0.0.1',
+      device_os: 'iOS',
+      device_os_version: '17.0',
+      device_os_detail: 'iOS 17.0',
+      device_manufacturer: 'apple',
+      device_model: 'test-model',
+      device_model_name: 'Test Phone',
+      device_brand: 'Apple',
+      device_is_physical: 'true',
+      device_id: 'preloaded-device-id',
+      device_type: 'mobile',
+      device_memory_total: '100',
+      device_memory_used: '50',
+    });
+
+    const faro = await initializeFaro(
+      mockConfig({
+        url: 'http://localhost:12345/collect',
+        transports: [new MockTransport()],
+        instrumentations: [new SessionInstrumentation()],
+        sessionTracking: {
+          enabled: true,
+          persistent: false,
+        },
+      })
+    );
+
+    expect(spy).toHaveBeenCalled();
+    expect(faro.metas.value.sdk?.name).toBe('faro-react-native');
+    expect(faro.metas.value.sdk?.version).toBe(VERSION);
+    expect(faro.metas.value.sdk?.integrations).toEqual([{ name: packageJson.name, version: packageJson.version }]);
+    expect(faro.metas.value.session?.attributes?.['react_native_version']).toBe('0.0.1');
+    expect(faro.metas.value.session?.attributes?.['device_id']).toBe('preloaded-device-id');
+
+    spy.mockRestore();
+  });
+});

package/src/initialize.ts

@@ -2,8 +2,14 @@ import { type Faro, initializeFaro as initializeFaroCore } from '@grafana/faro-c
 
 import { makeRNConfig } from './config/makeRNConfig';
 import type { ReactNativeConfig } from './config/types';
+import { loadSessionDeviceAttributesForInit } from './instrumentations/session/sessionAttributes';
 
-export function initializeFaro(config: ReactNativeConfig): Faro {
-  const fullConfig = makeRNConfig(config);
+/**
+ * Awaits async device/session attribute collection, then initializes Faro with core `initializeFaro`.
+ * On failure during collection, uses `minimalSessionDeviceAttributes` before init.
+ */
+export async function initializeFaro(config: ReactNativeConfig): Promise<Faro> {
+  const preloadedSessionDeviceAttributes = await loadSessionDeviceAttributesForInit();
+  const fullConfig = makeRNConfig(config, preloadedSessionDeviceAttributes);
   return initializeFaroCore(fullConfig);
 }

package/src/instrumentations/console/index.ts

@@ -25,6 +25,7 @@ export class ConsoleInstrumentation extends BaseInstrumentation {
   private originalConsole: Partial<Console> = {};
   private errorSerializer: LogArgsSerializer = reactNativeLogArgsSerializer;
   private patchedLevels: LogLevel[] = [];
+  private isProcessing = false;
 
   initialize(): void {
     const instrumentationOptions = this.config.consoleInstrumentation;
@@ -35,9 +36,11 @@ export class ConsoleInstrumentation extends BaseInstrumentation {
       ? (instrumentationOptions?.errorSerializer ?? defaultErrorArgsSerializer)
       : reactNativeLogArgsSerializer;
 
-    // Store original console methods
+    // Store original console methods - use unpatchedConsole from config if available
+    // to avoid capturing React Native's patched console (LogBox, DevTools)
+    const sourceConsole = this.config.unpatchedConsole ?? console;
     allLogLevels.forEach((level) => {
-      this.originalConsole[level] = console[level];
+      this.originalConsole[level] = sourceConsole[level];
     });
 
     // Determine which levels to patch
@@ -49,6 +52,13 @@ export class ConsoleInstrumentation extends BaseInstrumentation {
     // Patch console methods
     this.patchedLevels.forEach((level) => {
       console[level] = (...args: unknown[]) => {
+        // Prevent re-entry to avoid infinite loops
+        if (this.isProcessing) {
+          this.originalConsole[level]?.(...args);
+          return;
+        }
+
+        this.isProcessing = true;
         try {
           if (level === LogLevel.ERROR && !instrumentationOptions?.consoleErrorAsLog) {
             // Handle console.error as an error with advanced serialization
@@ -83,22 +93,15 @@ export class ConsoleInstrumentation extends BaseInstrumentation {
             // Handle other log levels normally
             this.api.pushLog(args, { level });
           }
-        } catch (err) {
-          // Use unpatchedConsole to avoid infinite loop
-          this.unpatchedConsole.error('[Faro Console] Error capturing log:', err);
-          this.logError(err);
+        } catch (_err) {
+          // Silently ignore errors to prevent infinite loops during bootstrap
         } finally {
-          // Always call original console method
+          // Always call original console method (still protected by isProcessing flag)
           this.originalConsole[level]?.(...args);
+          this.isProcessing = false;
         }
       };
     });
-
-    this.logInfo('Console instrumentation initialized', {
-      patchedLevels: this.patchedLevels,
-      serializeErrors,
-      consoleErrorAsLog: instrumentationOptions?.consoleErrorAsLog ?? false,
-    });
   }
 
   /**
@@ -113,6 +116,5 @@ export class ConsoleInstrumentation extends BaseInstrumentation {
     });
 
     this.patchedLevels = [];
-    this.logInfo('Console instrumentation unpatched');
   }
 }