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

package/src/instrumentations/session/sessionAttributes.test.ts

@@ -1,8 +1,6 @@
 import { Platform } from 'react-native';
 import DeviceInfo from 'react-native-device-info';
 
-import { VERSION } from '@grafana/faro-core';
-
 import { getSessionAttributes } from './sessionAttributes';
 
 // Mock react-native-device-info
@@ -66,7 +64,6 @@ describe('sessionAttributes', () => {
         const attributes = await getSessionAttributes();
 
         expect(attributes).toEqual({
-          faro_sdk_version: VERSION,
           react_native_version: '0.75.1',
           device_os: 'iOS',
           device_os_version: '17.0',
@@ -163,7 +160,6 @@ describe('sessionAttributes', () => {
         const attributes = await getSessionAttributes();
 
         expect(attributes).toEqual({
-          faro_sdk_version: VERSION,
           react_native_version: '0.75.1',
           device_os: 'Android',
           device_os_version: '15',
@@ -302,23 +298,12 @@ describe('sessionAttributes', () => {
 
         const attributes = await getSessionAttributes();
 
-        // Should return minimal attributes with fallbacks
+        // Device info is omitted when collection fails so nothing partial is sent to Faro
         expect(attributes).toEqual({
-          faro_sdk_version: VERSION,
           react_native_version: expect.any(String),
-          device_os: expect.stringMatching(/iOS|Android/),
-          device_os_version: 'unknown',
-          device_os_detail: 'unknown',
-          device_manufacturer: 'unknown',
-          device_model: 'unknown',
-          device_model_name: 'unknown',
-          device_brand: 'unknown',
-          device_is_physical: 'true',
-          device_id: 'unknown',
-          device_type: 'mobile',
-          device_memory_total: '0',
-          device_memory_used: '0',
         });
+        expect(attributes.device_id).toBeUndefined();
+        expect(attributes.device_os).toBeUndefined();
       });
 
       it('should handle partial DeviceInfo failures', async () => {
@@ -337,12 +322,13 @@ describe('sessionAttributes', () => {
 
         const attributes = await getSessionAttributes();
 
-        // Due to the catch-all error handling, when any method throws,
-        // the entire function returns fallback values
-        expect(attributes.device_id).toBe('unknown');
-        expect(attributes.device_os).toMatch(/iOS|Android/);
-        expect(attributes.device_model).toBe('unknown');
-        expect(attributes.device_manufacturer).toBe('unknown');
+        // Any synchronous DeviceInfo failure skips all device fields (minimal payload only)
+        expect(attributes).toEqual({
+          react_native_version: expect.any(String),
+        });
+        expect(attributes.device_id).toBeUndefined();
+        expect(attributes.device_manufacturer).toBeUndefined();
+        expect(attributes.device_model).toBeUndefined();
       });
     });
 
@@ -385,23 +371,5 @@ describe('sessionAttributes', () => {
         expect(attributes.device_manufacturer).toBe('oneplus');
       });
     });
-
-    describe('SDK version', () => {
-      it('should always include SDK version from @grafana/faro-core', async () => {
-        (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('uuid');
-        (DeviceInfo.getSystemName as jest.Mock).mockReturnValue('iOS');
-        (DeviceInfo.getSystemVersion as jest.Mock).mockReturnValue('17.0');
-        (DeviceInfo.getManufacturerSync as jest.Mock).mockReturnValue('Apple');
-        (DeviceInfo.getModel as jest.Mock).mockReturnValue('iPhone16,1');
-        (DeviceInfo.getDeviceNameSync as jest.Mock).mockReturnValue('iPhone 15 Pro');
-        (DeviceInfo.getBrand as jest.Mock).mockReturnValue('Apple');
-        (DeviceInfo.isEmulatorSync as jest.Mock).mockReturnValue(false);
-
-        const attributes = await getSessionAttributes();
-
-        expect(attributes.faro_sdk_version).toBe(VERSION);
-        expect(attributes.faro_sdk_version).toMatch(/^\d+\.\d+\.\d+/);
-      });
-    });
   });
 });

package/src/instrumentations/session/sessionAttributes.ts

@@ -1,57 +1,56 @@
 import { Platform } from 'react-native';
 import DeviceInfo from 'react-native-device-info';
 
-import { VERSION } from '@grafana/faro-core';
-
 /**
  * Session attributes for React Native
  * These attributes are automatically included with every telemetry event
  *
  * Core attributes match Flutter SDK format, with additional mobile-specific
  * monitoring fields (memory, device type, battery, etc.)
+ *
+ * SDK name, core version, and npm adapter are on Faro meta `sdk` (`getSdkMeta` in `metas/sdk.ts`).
+ *
+ * `react_native_version` is the host app's React Native **framework** version from `Platform`, not the Faro package.
  */
 export interface SessionAttributes {
-  /** SDK version (e.g., "2.0.2") */
-  faro_sdk_version: string;
-
-  /** React Native version (e.g., "0.75.1") */
+  /** Host app's React Native framework version (e.g. "0.75.1") from `Platform.constants`. */
   react_native_version: string;
 
   /** Operating system ("iOS" or "Android") */
-  device_os: string;
+  device_os?: string;
 
   /** OS version (e.g., "17.0" for iOS, "15" for Android) */
-  device_os_version: string;
+  device_os_version?: string;
 
   /** Detailed OS info (e.g., "iOS 17.0" or "Android 15 (SDK 35)") */
-  device_os_detail: string;
+  device_os_detail?: string;
 
   /** Device manufacturer (e.g., "apple", "samsung") */
-  device_manufacturer: string;
+  device_manufacturer?: string;
 
   /** Raw model identifier (e.g., "iPhone16,1", "SM-A155F") */
-  device_model: string;
+  device_model?: string;
 
   /** Human-readable model name (e.g., "iPhone 15 Pro") */
-  device_model_name: string;
+  device_model_name?: string;
 
   /** Device brand (e.g., "iPhone", "samsung") */
-  device_brand: string;
+  device_brand?: string;
 
   /** Whether device is physical or emulator ("true" or "false") */
-  device_is_physical: string;
+  device_is_physical?: string;
 
   /** Unique device ID (UUID) */
-  device_id: string;
+  device_id?: string;
 
   /** Device type ("mobile" or "tablet") */
-  device_type: string;
+  device_type?: string;
 
   /** Total device memory in bytes */
-  device_memory_total: string;
+  device_memory_total?: string;
 
   /** Currently used memory in bytes */
-  device_memory_used: string;
+  device_memory_used?: string;
 
   /** Battery level percentage (e.g., "85") - empty if unavailable */
   device_battery_level?: string;
@@ -67,12 +66,10 @@ export interface SessionAttributes {
 }
 
 /**
- * Get React Native version from Platform
- * Returns "unknown" if not available
+ * React Native framework version from `Platform.constants` (host app runtime), not `@grafana/faro-react-native` semver.
  */
 function getReactNativeVersion(): string {
   try {
-    // Platform.constants.reactNativeVersion is an object like { major: 0, minor: 75, patch: 1 }
     const version = Platform.constants.reactNativeVersion;
     if (version && typeof version === 'object') {
       const { major, minor, patch, prerelease } = version as {
@@ -127,12 +124,22 @@ async function getDeviceOsDetail(): Promise<string> {
   return `${systemName} ${systemVersion}`;
 }
 
+/**
+ * Session attributes without device props when async collection or DeviceInfo is unavailable.
+ * No synchronous DeviceInfo reads — use {@link getSessionAttributes} or the package async `initializeFaro`.
+ */
+export function minimalSessionDeviceAttributes(): SessionAttributes {
+  return {
+    react_native_version: getReactNativeVersion(),
+  };
+}
+
 /**
  * Get all session attributes
  * These attributes are automatically included with every telemetry event
  *
  * Core attributes matching Flutter SDK:
- * - faro_sdk_version, react_native_version
+ * - react_native_version (RN framework in the host app)
  * - device_os, device_os_version, device_os_detail
  * - device_manufacturer, device_model, device_model_name
  * - device_brand, device_is_physical, device_id
@@ -162,8 +169,6 @@ export async function getSessionAttributes(): Promise<SessionAttributes> {
     // Memory info
     const totalMemory = DeviceInfo.getTotalMemorySync();
     const usedMemory = DeviceInfo.getUsedMemorySync();
-
-    // React Native version (equivalent to dart_version in Flutter)
     const reactNativeVersion = getReactNativeVersion();
 
     // Try to get async device info (battery, carrier)
@@ -207,7 +212,6 @@ export async function getSessionAttributes(): Promise<SessionAttributes> {
     }
 
     const attributes: SessionAttributes = {
-      faro_sdk_version: VERSION,
       react_native_version: reactNativeVersion,
       device_os: systemName,
       device_os_version: systemVersion,
@@ -229,22 +233,18 @@ export async function getSessionAttributes(): Promise<SessionAttributes> {
 
     return attributes;
   } catch (_error) {
-    // If anything fails, return minimal attributes
-    return {
-      faro_sdk_version: VERSION,
-      react_native_version: getReactNativeVersion(),
-      device_os: Platform.OS === 'ios' ? 'iOS' : 'Android',
-      device_os_version: 'unknown',
-      device_os_detail: 'unknown',
-      device_manufacturer: 'unknown',
-      device_model: 'unknown',
-      device_model_name: 'unknown',
-      device_brand: 'unknown',
-      device_is_physical: 'true',
-      device_id: 'unknown',
-      device_type: 'mobile',
-      device_memory_total: '0',
-      device_memory_used: '0',
-    };
+    return minimalSessionDeviceAttributes();
+  }
+}
+
+/**
+ * Await full async session device attributes (battery, carrier, etc.), then fall back to
+ * {@link minimalSessionDeviceAttributes} if anything throws. Used by async `initializeFaro`.
+ */
+export async function loadSessionDeviceAttributesForInit(): Promise<SessionAttributes> {
+  try {
+    return await getSessionAttributes();
+  } catch {
+    return minimalSessionDeviceAttributes();
   }
 }

package/src/instrumentations/session/sessionManager/{PersistentSessionsManager.ts → MmkvPersistentSessionsManager.ts}

@@ -1,5 +1,5 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
 import { AppState, type AppStateStatus } from 'react-native';
+import type { MMKV } from 'react-native-mmkv';
 
 import { faro, stringifyExternalJson } from '@grafana/faro-core';
 
@@ -9,50 +9,74 @@ import { STORAGE_KEY, STORAGE_UPDATE_DELAY } from './sessionConstants';
 import { getSessionMetaUpdateHandler, getUserSessionUpdater } from './sessionManagerUtils';
 import type { FaroUserSession } from './types';
 
-export class PersistentSessionsManager {
+function createMmkvInstance(): MMKV {
+  try {
+    const { MMKV } = require('react-native-mmkv');
+    return new MMKV({ id: 'grafana-faro-react-native-session' });
+  } catch {
+    throw new Error(
+      'sessionTracking.persistent is true but react-native-mmkv could not be loaded. Install it: yarn add react-native-mmkv, then rebuild native projects.'
+    );
+  }
+}
+
+let mmkvSingleton: MMKV | undefined;
+
+function getMmkv(): MMKV {
+  if (mmkvSingleton == null) {
+    mmkvSingleton = createMmkvInstance();
+  }
+  return mmkvSingleton;
+}
+
+/** @internal */
+export function resetMmkvSingletonForTests(): void {
+  mmkvSingleton = undefined;
+}
+
+/**
+ * Persistent session storage backed by MMKV (synchronous reads/writes).
+ * Used when `sessionTracking.persistent` is true.
+ */
+export class MmkvPersistentSessionsManager {
   private updateUserSession: ReturnType<typeof getUserSessionUpdater>;
   private appStateSubscription: ReturnType<typeof AppState.addEventListener> | null = null;
   private metaUnsubscribe: (() => void) | null = null;
 
   constructor() {
     this.updateUserSession = getUserSessionUpdater({
-      fetchUserSession: PersistentSessionsManager.fetchUserSession,
-      storeUserSession: PersistentSessionsManager.storeUserSession,
+      fetchUserSession: MmkvPersistentSessionsManager.fetchUserSession,
+      storeUserSession: MmkvPersistentSessionsManager.storeUserSession,
     });
 
     this.init();
   }
 
-  static async removeUserSession(): Promise<void> {
+  static removeUserSession(): void {
     try {
-      await AsyncStorage.removeItem(STORAGE_KEY);
+      getMmkv().remove(STORAGE_KEY);
     } catch (error) {
-      // Silently fail - AsyncStorage errors shouldn't break the app
-      faro.unpatchedConsole?.warn?.('Failed to remove session from AsyncStorage:', error);
+      faro.unpatchedConsole?.warn?.('Failed to remove session from MMKV:', error);
     }
   }
 
-  static async storeUserSession(session: FaroUserSession): Promise<void> {
+  static storeUserSession(session: FaroUserSession): void {
     try {
-      await AsyncStorage.setItem(STORAGE_KEY, stringifyExternalJson(session));
+      getMmkv().set(STORAGE_KEY, stringifyExternalJson(session));
     } catch (error) {
-      // Silently fail - AsyncStorage errors shouldn't break the app
-      faro.unpatchedConsole?.warn?.('Failed to store session in AsyncStorage:', error);
+      faro.unpatchedConsole?.warn?.('Failed to store session in MMKV:', error);
     }
   }
 
-  static async fetchUserSession(): Promise<FaroUserSession | null> {
+  static fetchUserSession(): FaroUserSession | null {
     try {
-      const storedSession = await AsyncStorage.getItem(STORAGE_KEY);
-
+      const storedSession = getMmkv().getString(STORAGE_KEY);
       if (storedSession) {
         return JSON.parse(storedSession) as FaroUserSession;
       }
-
       return null;
     } catch (error) {
-      // Silently fail - AsyncStorage errors shouldn't break the app
-      faro.unpatchedConsole?.warn?.('Failed to fetch session from AsyncStorage:', error);
+      faro.unpatchedConsole?.warn?.('Failed to fetch session from MMKV:', error);
       return null;
     }
   }
@@ -66,22 +90,17 @@ export class PersistentSessionsManager {
   };
 
   private init(): void {
-    // Listen to app state changes (equivalent to visibilitychange in web)
     this.appStateSubscription = AppState.addEventListener('change', this.handleAppStateChange);
 
-    // Users can call the setSession() method, so we need to sync this with AsyncStorage
     const unsubscribe = faro.metas.addListener(
       getSessionMetaUpdateHandler({
-        fetchUserSession: PersistentSessionsManager.fetchUserSession,
-        storeUserSession: PersistentSessionsManager.storeUserSession,
+        fetchUserSession: MmkvPersistentSessionsManager.fetchUserSession,
+        storeUserSession: MmkvPersistentSessionsManager.storeUserSession,
       })
     );
     this.metaUnsubscribe = typeof unsubscribe === 'function' ? unsubscribe : null;
   }
 
-  /**
-   * Clean up listeners when the instrumentation is unpatched
-   */
   unpatch(): void {
     if (this.appStateSubscription) {
       this.appStateSubscription.remove();

package/src/instrumentations/session/sessionManager/getSessionManagerByConfig.ts

@@ -1,9 +1,13 @@
 import type { Config } from '@grafana/faro-core';
 
-import { PersistentSessionsManager } from './PersistentSessionsManager';
+import { MmkvPersistentSessionsManager } from './MmkvPersistentSessionsManager';
 import type { SessionManager } from './types';
 import { VolatileSessionsManager } from './VolatileSessionManager';
 
 export function getSessionManagerByConfig(sessionTrackingConfig: Required<Config>['sessionTracking']): SessionManager {
-  return sessionTrackingConfig.persistent ? PersistentSessionsManager : VolatileSessionsManager;
+  if (!sessionTrackingConfig.persistent) {
+    return VolatileSessionsManager;
+  }
+
+  return MmkvPersistentSessionsManager;
 }

package/src/instrumentations/session/sessionManager/index.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/src/instrumentations/session/sessionManager/types.ts

@@ -1,6 +1,6 @@
 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 {
@@ -11,4 +11,4 @@ export interface FaroUserSession {
   sessionMeta?: MetaSession;
 }
 
-export type SessionManager = typeof VolatileSessionsManager | typeof PersistentSessionsManager;
+export type SessionManager = typeof VolatileSessionsManager | typeof MmkvPersistentSessionsManager;

package/src/internalLogger/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Internal logger levels - copied from @grafana/faro-core to avoid bundling web code
+ * Keep in sync with @grafana/faro-core's InternalLoggerLevel
+ */
+export 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 enum LogLevel {
+  TRACE = 'trace',
+  DEBUG = 'debug',
+  INFO = 'info',
+  LOG = 'log',
+  WARN = 'warn',
+  ERROR = 'error',
+}
+
+export const defaultLogLevel = LogLevel.LOG;
+export const allLogLevels: ReadonlyArray<Readonly<LogLevel>> = [
+  LogLevel.TRACE,
+  LogLevel.DEBUG,
+  LogLevel.INFO,
+  LogLevel.LOG,
+  LogLevel.WARN,
+  LogLevel.ERROR,
+] as const;

package/src/metas/sdk.test.ts

@@ -1,155 +1,19 @@
-import { initializeFaro, VERSION } from '@grafana/faro-core';
-import { mockConfig } from '@grafana/faro-test-utils';
+import { VERSION } from '@grafana/faro-core';
 
-import { getSdkMeta } from './sdk';
-
-describe('SDK meta', () => {
-  describe('getSdkMeta', () => {
-    it('returns SDK name and version', () => {
-      const config = mockConfig({});
-      initializeFaro(config);
-
-      const sdkMeta = getSdkMeta();
-      const meta = sdkMeta();
-
-      expect(meta.sdk.name).toBe('@grafana/faro-react-native');
-      expect(meta.sdk.version).toBe(VERSION);
-    });
-
-    it('includes integrations from instrumentations', () => {
-      const mockInstrumentation1 = {
-        name: 'test-instrumentation-1',
-        version: '1.0.0',
-        initialize: jest.fn(),
-      };
-
-      const mockInstrumentation2 = {
-        name: 'test-instrumentation-2',
-        version: '2.0.0',
-        initialize: jest.fn(),
-      };
-
-      const config = mockConfig({
-        instrumentations: [mockInstrumentation1, mockInstrumentation2] as any,
-      });
-
-      initializeFaro(config);
-
-      const sdkMeta = getSdkMeta();
-      const meta = sdkMeta();
-
-      expect(meta.sdk.integrations).toHaveLength(2);
-      expect(meta.sdk.integrations).toEqual([
-        { name: 'test-instrumentation-1', version: '1.0.0' },
-        { name: 'test-instrumentation-2', version: '2.0.0' },
-      ]);
-    });
-
-    it('returns empty integrations array when no instrumentations', () => {
-      const config = mockConfig({
-        instrumentations: [],
-      });
-
-      initializeFaro(config);
-
-      const sdkMeta = getSdkMeta();
-      const meta = sdkMeta();
-
-      expect(meta.sdk.integrations).toEqual([]);
-    });
-
-    it('extracts only name and version from instrumentations', () => {
-      const mockInstrumentation = {
-        name: 'test-instrumentation',
-        version: '1.0.0',
-        initialize: jest.fn(),
-        otherProperty: 'should-not-appear',
-        anotherProperty: 123,
-      };
-
-      const config = mockConfig({
-        instrumentations: [mockInstrumentation] as any,
-      });
-
-      initializeFaro(config);
-
-      const sdkMeta = getSdkMeta();
-      const meta = sdkMeta();
+import packageJson from '../../package.json';
+import { FARO_REACT_NATIVE_NPM_NAME, FARO_REACT_NATIVE_NPM_VERSION } from '../generated/faroRNPackageMeta';
 
-      expect(meta.sdk.integrations).toEqual([{ name: 'test-instrumentation', version: '1.0.0' }]);
-      expect(meta.sdk.integrations[0]).not.toHaveProperty('initialize');
-      expect(meta.sdk.integrations[0]).not.toHaveProperty('otherProperty');
-      expect(meta.sdk.integrations[0]).not.toHaveProperty('anotherProperty');
-    });
-
-    it('returns a function that can be called multiple times', () => {
-      const config = mockConfig({});
-      initializeFaro(config);
-
-      const sdkMeta = getSdkMeta();
-
-      const meta1 = sdkMeta();
-      const meta2 = sdkMeta();
-
-      expect(meta1).toEqual(meta2);
-      expect(meta1.sdk.name).toBe('@grafana/faro-react-native');
-      expect(meta2.sdk.name).toBe('@grafana/faro-react-native');
-    });
-
-    it('returns consistent structure', () => {
-      const config = mockConfig({});
-      initializeFaro(config);
-
-      const sdkMeta = getSdkMeta();
-      const meta = sdkMeta();
-
-      expect(meta).toHaveProperty('sdk');
-      expect(meta.sdk).toHaveProperty('name');
-      expect(meta.sdk).toHaveProperty('version');
-      expect(meta.sdk).toHaveProperty('integrations');
-      expect(Array.isArray(meta.sdk.integrations)).toBe(true);
-    });
-
-    it('handles instrumentations with only required properties', () => {
-      const mockInstrumentation = {
-        name: 'minimal-instrumentation',
-        version: '1.0.0',
-        initialize: jest.fn(),
-      };
-
-      const config = mockConfig({
-        instrumentations: [mockInstrumentation] as any,
-      });
-
-      initializeFaro(config);
-
-      const sdkMeta = getSdkMeta();
-      const meta = sdkMeta();
-
-      expect(meta.sdk.integrations).toEqual([{ name: 'minimal-instrumentation', version: '1.0.0' }]);
-    });
-
-    it('maps multiple instrumentations preserving order', () => {
-      const instrumentations = [
-        { name: 'first', version: '1.0.0', initialize: jest.fn() },
-        { name: 'second', version: '2.0.0', initialize: jest.fn() },
-        { name: 'third', version: '3.0.0', initialize: jest.fn() },
-      ];
-
-      const config = mockConfig({
-        instrumentations: instrumentations as any,
-      });
-
-      initializeFaro(config);
-
-      const sdkMeta = getSdkMeta();
-      const meta = sdkMeta();
+import { getSdkMeta } from './sdk';
 
-      expect(meta.sdk.integrations).toEqual([
-        { name: 'first', version: '1.0.0' },
-        { name: 'second', version: '2.0.0' },
-        { name: 'third', version: '3.0.0' },
-      ]);
-    });
+describe('getSdkMeta', () => {
+  it('should set core sdk line and npm integration from generated meta', () => {
+    const meta = getSdkMeta()();
+    expect(meta.sdk?.name).toBe('faro-react-native');
+    expect(meta.sdk?.version).toBe(VERSION);
+    expect(meta.sdk?.integrations).toEqual([
+      { name: FARO_REACT_NATIVE_NPM_NAME, version: FARO_REACT_NATIVE_NPM_VERSION },
+    ]);
+    expect(FARO_REACT_NATIVE_NPM_NAME).toBe(packageJson.name);
+    expect(FARO_REACT_NATIVE_NPM_VERSION).toBe(packageJson.version);
   });
 });

package/src/metas/sdk.ts

@@ -1,19 +1,25 @@
-import { faro, VERSION } from '@grafana/faro-core';
+import { VERSION } from '@grafana/faro-core';
 import type { Meta, MetaItem } from '@grafana/faro-core';
 
+import { FARO_REACT_NATIVE_NPM_NAME, FARO_REACT_NATIVE_NPM_VERSION } from '../generated/faroRNPackageMeta';
+
 /**
- * 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 const getSdkMeta = (): MetaItem<Pick<Meta, 'sdk'>> => {
   return () => ({
     sdk: {
-      name: '@grafana/faro-react-native',
+      name: 'faro-react-native',
       version: VERSION,
-      integrations: faro.config.instrumentations.map((instrumentation: { name: string; version: string }) => ({
-        name: instrumentation.name,
-        version: instrumentation.version,
-      })),
+      integrations: [
+        {
+          name: FARO_REACT_NATIVE_NPM_NAME,
+          version: FARO_REACT_NATIVE_NPM_VERSION,
+        },
+      ],
     },
   });
 };

package/src/testUtils/mockFaroReactNativeTracing.ts

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