@grafana/faro-react-native 1.2.1 → 1.3.1

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.3.1";
+    readonly version = "2.8.2";
     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.3.1";
+    readonly version = "2.8.2";
     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.3.1";
+    readonly version = "2.8.2";
     private readonly cache;
     private readonly connectivityService;
     private readonly maxCacheDurationMs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grafana/faro-react-native",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Faro instrumentations, metas, transports for React Native.",
   "keywords": [
     "observability",
@@ -56,7 +56,7 @@
     "version": "node ./scripts/sync-faro-rn-package-meta.mjs && git add src/generated/faroRNPackageMeta.ts"
   },
   "dependencies": {
-    "@grafana/faro-core": "^2.2.3",
+    "@grafana/faro-core": "^2.8.2",
     "@react-native-async-storage/async-storage": "^1.21.0",
     "react-native-device-info": "^11.1.0"
   },
@@ -79,10 +79,10 @@
     "@types/react": "19.2.15",
     "@types/react-native": "0.73.0",
     "react-native-mmkv": "4.3.1",
-    "react-native-nitro-modules": "0.35.6"
+    "react-native-nitro-modules": "0.36.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ae48b3fc6f2fc4201d634edd38e2713f459dd008"
+  "gitHead": "fed3084557bb9c34129fff2b190ad4758fad7daf"
 }

package/src/config/getRNInstrumentations.ts

@@ -144,7 +144,11 @@ export function getRNInstrumentations(config: Partial<ReactNativeConfig> = {}):
 
   // Crash reporting
   if (enableCrashReporting) {
-    instrumentations.push(new CrashReportingInstrumentation());
+    instrumentations.push(
+      new CrashReportingInstrumentation({
+        releaseBundleFilename: config.releaseBundleFilename,
+      })
+    );
   }
 
   if (enableTracing) {

package/src/config/makeRNConfig.test.ts

@@ -1,6 +1,9 @@
 import { BaseInstrumentation, VERSION } from '@grafana/faro-core';
 
-import { minimalSessionDeviceAttributes } from '../instrumentations/session/sessionAttributes';
+import {
+  minimalSessionDeviceAttributes,
+  type PreloadedMobileMeta,
+} from '../instrumentations/session/sessionAttributes';
 import { defaultSessionTrackingConfig } from '../instrumentations/session/sessionManager/sessionConstants';
 import { ConsoleTransport } from '../transports/console';
 import { FetchTransport } from '../transports/fetch';
@@ -116,16 +119,69 @@ describe('makeRNConfig', () => {
     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', () => {
+  it('passes preloaded mobile meta and flat session device attributes to core config', () => {
     const preloaded = minimalSessionDeviceAttributes();
     preloaded.device_id = 'test-preloaded-id';
-    const cfg = makeRNConfig({ ...base }, preloaded);
+    const preloadedMobileMeta: PreloadedMobileMeta = {
+      sessionAttributes: preloaded,
+      meta: {
+        app: {
+          installationId: 'test-installation-id',
+        },
+        device: {
+          is_physical: true,
+          model_identifier: 'iPhone16,1',
+        },
+        os: {
+          name: 'iOS',
+          version: '17.0',
+        },
+      },
+    };
+
+    const cfg = makeRNConfig({ ...base }, preloadedMobileMeta);
+
+    expect(cfg.app.name).toBe('test-app');
+    expect(cfg.app.installationId).toBe('test-installation-id');
+    expect(cfg.preloadedMobileMeta).toEqual(preloadedMobileMeta.meta);
     expect(
       (cfg as { preloadedSessionDeviceAttributes?: { device_id: string } }).preloadedSessionDeviceAttributes
     ).toBeDefined();
     expect(
       (cfg as { preloadedSessionDeviceAttributes?: { device_id: string } }).preloadedSessionDeviceAttributes?.device_id
     ).toBe('test-preloaded-id');
+    expect(cfg.metas).toContainEqual({
+      device: {
+        is_physical: true,
+        model_identifier: 'iPhone16,1',
+      },
+      os: {
+        name: 'iOS',
+        version: '17.0',
+      },
+    });
+  });
+
+  it('keeps explicit config app installationId over preloaded installationId', () => {
+    const cfg = makeRNConfig(
+      {
+        ...base,
+        app: {
+          ...base.app,
+          installationId: 'explicit-installation-id',
+        },
+      },
+      {
+        sessionAttributes: minimalSessionDeviceAttributes(),
+        meta: {
+          app: {
+            installationId: 'preloaded-installation-id',
+          },
+        },
+      }
+    );
+
+    expect(cfg.app.installationId).toBe('explicit-installation-id');
   });
 
   it('uses releaseBundleFilename in default parseStacktrace when set', () => {

package/src/config/makeRNConfig.ts

@@ -1,10 +1,11 @@
 import { defaultGlobalObjectKey, defaultUnpatchedConsole } from '@grafana/faro-core';
-import type { Config } from '@grafana/faro-core';
+import type { Config, MetaApp } from '@grafana/faro-core';
 
 import { getStackFramesFromError } from '../instrumentations/errors/stackTraceParser';
-import type { SessionAttributes } from '../instrumentations/session/sessionAttributes';
+import type { PreloadedMobileMeta } from '../instrumentations/session/sessionAttributes';
 import { defaultSessionTrackingConfig } from '../instrumentations/session/sessionManager/sessionConstants';
 import { InternalLoggerLevel, LogLevel } from '../internalLogger';
+import { getMetroInjectedBundleId } from '../metas/appBuildIdentity';
 import { getPageMeta } from '../metas/page';
 import { getScreenMeta } from '../metas/screen';
 import { getSdkMeta } from '../metas/sdk';
@@ -17,6 +18,28 @@ import type { ReactNativeConfig, ReactNativeFullConfig } from './types';
 
 const DEFAULT_OFFLINE_CACHE_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
 
+/**
+ * Resolves `meta.app.bundleId` when it is not already supplied by faro-core from
+ * the Metro preamble (`registerInitialMetas` / `__faroBundleId_<appName>`).
+ *
+ * Priority: explicit `config.app.bundleId` → Metro preamble (core) → DeviceInfo
+ * fallback (`applicationId@versionCode@versionName`, same shape Gradle/Metro use).
+ */
+function resolveAppBundleId(
+  configApp: MetaApp | undefined,
+  appName: string | undefined,
+  appSymbolsBundleId?: string
+): string | undefined {
+  if (configApp?.bundleId) {
+    return configApp.bundleId;
+  }
+  const metroId = getMetroInjectedBundleId(appName);
+  if (metroId) {
+    return metroId;
+  }
+  return appSymbolsBundleId;
+}
+
 /**
  * Builds transports. FetchTransport is always added when url is provided.
  * User can enable offline and console via enableTransports.
@@ -77,22 +100,38 @@ function createParseStacktrace(releaseBundleFilename: string | undefined): Confi
  * 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`).
+ * @param preloadedMobileMeta Device/session fields and structured mobile meta (passed from async `initializeFaro`).
+ * @param appSymbolsBundleId Encoded `meta.app.bundleId` for server-side symbol retrace.
  */
 export function makeRNConfig(
   config: ReactNativeConfig,
-  preloadedSessionDeviceAttributes?: SessionAttributes
+  preloadedMobileMeta?: PreloadedMobileMeta,
+  appSymbolsBundleId?: string
 ): ReactNativeFullConfig {
-  const defaultMetas = [getSdkMeta(), getPageMeta(), getScreenMeta()];
+  const { app: preloadedAppMeta, ...structuredMobileMeta } = preloadedMobileMeta?.meta ?? {};
+  const mobileMetas = Object.keys(structuredMobileMeta).length > 0 ? [structuredMobileMeta] : [];
+  const defaultMetas = [getSdkMeta(), getPageMeta(), getScreenMeta(), ...mobileMetas];
   const customMetas = config.metas ?? [];
   const transports = buildTransports(config);
   const instrumentations = buildInstrumentations(config);
+  const installationId = config.app.installationId ?? preloadedAppMeta?.installationId;
 
   const releaseBundleFilename = config.releaseBundleFilename;
+  // Merge bundleId (from config, Metro, or DeviceInfo) with preloaded app meta
+  const bundleIdValue = resolveAppBundleId(config.app, config.app?.name, appSymbolsBundleId);
+  const appMetasIfPresent =
+    preloadedAppMeta || bundleIdValue
+      ? [{ app: { ...preloadedAppMeta, ...(bundleIdValue && { bundleId: bundleIdValue }) } }]
+      : [];
+
   return {
-    app: config.app,
-    ...(preloadedSessionDeviceAttributes != null && {
-      preloadedSessionDeviceAttributes,
+    app: {
+      ...config.app,
+      ...(installationId && { installationId }),
+    },
+    ...(preloadedMobileMeta != null && {
+      preloadedMobileMeta: preloadedMobileMeta.meta,
+      preloadedSessionDeviceAttributes: preloadedMobileMeta.sessionAttributes,
     }),
     dedupe: config.dedupe ?? true,
     globalObjectKey: config.globalObjectKey ?? defaultGlobalObjectKey,
@@ -111,7 +150,7 @@ export function makeRNConfig(
       ...defaultSessionTrackingConfig,
       ...config.sessionTracking,
     },
-    metas: [...defaultMetas, ...customMetas],
+    metas: [...defaultMetas, ...customMetas, ...appMetasIfPresent],
     instrumentations,
     transports,
     ignoreUrls: config.ignoreUrls ?? [],

package/src/config/types.ts

@@ -2,7 +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 { PreloadedMobileMeta, SessionAttributes } from '../instrumentations/session/sessionAttributes';
 
 import type { Sampling } from './sampling';
 
@@ -92,5 +92,6 @@ export type ReactNativeConfig = Partial<
  * Extends faro-core `Config` with RN-specific fields that instrumentations need at init time.
  */
 export type ReactNativeFullConfig = Config & {
+  preloadedMobileMeta?: PreloadedMobileMeta['meta'];
   preloadedSessionDeviceAttributes?: SessionAttributes;
 };

package/src/generated/faroRNPackageMeta.ts

@@ -2,4 +2,4 @@
  * 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.2.1' as const;
+export const FARO_REACT_NATIVE_NPM_VERSION = '1.3.1' as const;

package/src/index.ts

@@ -21,10 +21,11 @@ export { ConsoleInstrumentation } from './instrumentations/console';
 export { SessionInstrumentation } from './instrumentations/session';
 export {
   getSessionAttributes,
+  loadMobileMetaForInit,
   loadSessionDeviceAttributesForInit,
   minimalSessionDeviceAttributes,
 } from './instrumentations/session/sessionAttributes';
-export type { SessionAttributes } from './instrumentations/session/sessionAttributes';
+export type { PreloadedMobileMeta, SessionAttributes } from './instrumentations/session/sessionAttributes';
 export { ViewInstrumentation } from './instrumentations/view';
 export { AppStateInstrumentation } from './instrumentations/appState';
 export { UserActionInstrumentation } from './instrumentations/userActions';

package/src/initialize.test.ts

@@ -92,21 +92,41 @@ describe('initializeFaro', () => {
     ).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',
+  it('should await mobile meta then merge structured meta and preloaded session attributes', async () => {
+    const spy = jest.spyOn(sessionAttributes, 'loadMobileMetaForInit').mockResolvedValue({
+      sessionAttributes: {
+        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 Phone',
+        device_model_name: "Test's iPhone",
+        device_brand: 'Apple',
+        device_is_physical: 'true',
+        device_id: 'preloaded-device-id',
+        device_type: 'mobile',
+        device_memory_total: '100',
+        device_memory_used: '50',
+      },
+      meta: {
+        app: {
+          installationId: 'preloaded-installation-id',
+        },
+        device: {
+          brand: 'iPhone',
+          is_physical: true,
+          manufacturer: 'apple',
+          model_identifier: 'test-model-identifier',
+          model_name: 'Test Phone',
+          type: 'mobile',
+        },
+        os: {
+          detail: 'iOS 17.0',
+          name: 'iOS',
+          version: '17.0',
+        },
+      },
     });
 
     const faro = await initializeFaro(
@@ -125,6 +145,9 @@ describe('initializeFaro', () => {
     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.app?.installationId).toBe('preloaded-installation-id');
+    expect(faro.metas.value.device?.model_identifier).toBe('test-model-identifier');
+    expect(faro.metas.value.os?.name).toBe('iOS');
     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');
 
@@ -148,4 +171,37 @@ describe('initializeFaro', () => {
 
     expect(faro.metas.value.app?.bundleId).toBe('release-bundle-from-metro');
   });
+
+  it('should keep config.app.bundleId when set explicitly (do not override with symbols id)', async () => {
+    const faro = await initializeFaro(
+      mockConfig({
+        url: 'http://localhost:12345/collect',
+        app: { bundleId: 'user-env-bundle-id' },
+        transports: [new MockTransport()],
+        instrumentations: [new SessionInstrumentation()],
+        sessionTracking: {
+          enabled: true,
+          persistent: false,
+        },
+      })
+    );
+
+    expect(faro.metas.value.app?.bundleId).toBe('user-env-bundle-id');
+  });
+
+  it('should set meta.app.bundleId (encoded build identity) from DeviceInfo when no Metro id', async () => {
+    const faro = await initializeFaro(
+      mockConfig({
+        url: 'http://localhost:12345/collect',
+        transports: [new MockTransport()],
+        instrumentations: [new SessionInstrumentation()],
+        sessionTracking: {
+          enabled: true,
+          persistent: false,
+        },
+      })
+    );
+
+    expect(faro.metas.value.app?.bundleId).toBe('com.example.myapp@42@1.0.0');
+  });
 });

package/src/initialize.ts

@@ -2,14 +2,20 @@ 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';
+import { loadMobileMetaForInit } from './instrumentations/session/sessionAttributes';
+import { loadAppSymbolsBundleIdForInit } from './metas/appBuildIdentity';
 
 /**
- * Awaits async device/session attribute collection, then initializes Faro with core `initializeFaro`.
- * On failure during collection, uses `minimalSessionDeviceAttributes` before init.
+ * Awaits async device/session attribute collection and the build identity used
+ * for server-side symbol retrace, then initializes Faro with core
+ * `initializeFaro`. On failure during collection, uses
+ * `minimalSessionDeviceAttributes` / an empty build identity before init.
  */
 export async function initializeFaro(config: ReactNativeConfig): Promise<Faro> {
-  const preloadedSessionDeviceAttributes = await loadSessionDeviceAttributesForInit();
-  const fullConfig = makeRNConfig(config, preloadedSessionDeviceAttributes);
+  const [preloadedMobileMeta, appSymbolsBundleId] = await Promise.all([
+    loadMobileMetaForInit(),
+    loadAppSymbolsBundleIdForInit(),
+  ]);
+  const fullConfig = makeRNConfig(config, preloadedMobileMeta, appSymbolsBundleId);
   return initializeFaroCore(fullConfig);
 }

package/src/instrumentations/anr/anrStack.test.ts

@@ -0,0 +1,27 @@
+import { isInvalidAnrCaptureStack } from './anrStack';
+
+describe('isInvalidAnrCaptureStack', () => {
+  it('rejects empty stacks', () => {
+    expect(isInvalidAnrCaptureStack(undefined)).toBe(true);
+    expect(isInvalidAnrCaptureStack('')).toBe(true);
+  });
+
+  it('rejects crash-handler contamination', () => {
+    const stack = `
+    at com.android.internal.os.RuntimeInit$KillApplicationHandler.uncaughtException(RuntimeInit.java:174)
+    at com.grafana.faro.reactnative.FaroUncaughtExceptionHandler.uncaughtException(FaroUncaughtExceptionHandler.kt:42)
+    `.trim();
+
+    expect(isInvalidAnrCaptureStack(stack)).toBe(true);
+  });
+
+  it('accepts a typical blocked main-thread stack', () => {
+    const stack = `
+    at com.example.myapp.ui.HomeFragment.loadCatalog(HomeFragment.kt:84)
+    at com.example.myapp.ui.HomeFragment.onResume(HomeFragment.kt:52)
+    at android.app.Activity.performResume(Activity.java:8911)
+    `.trim();
+
+    expect(isInvalidAnrCaptureStack(stack)).toBe(false);
+  });
+});

package/src/instrumentations/anr/anrStack.ts

@@ -0,0 +1,19 @@
+/**
+ * Returns true when an ANR stack was sampled on the crash-killer path instead of
+ * the blocked main thread (common when ANRTracker fires during process teardown).
+ *
+ * Uses only Android framework and Faro SDK frame names — no app-specific identifiers.
+ */
+export function isInvalidAnrCaptureStack(stack: string | undefined): boolean {
+  if (!stack?.trim()) {
+    return true;
+  }
+
+  const normalized = stack.toLowerCase();
+
+  return (
+    normalized.includes('handleapplicationcrash') ||
+    normalized.includes('killapplicationhandler') ||
+    normalized.includes('farouncaughtexceptionhandler')
+  );
+}

package/src/instrumentations/anr/instrumentation.test.ts

@@ -0,0 +1,45 @@
+import { type ExceptionEvent, initializeFaro, type TransportItem } from '@grafana/faro-core';
+import { mockConfig, MockTransport } from '@grafana/faro-test-utils';
+
+import { ANRInstrumentation } from './instrumentation';
+
+describe('ANRInstrumentation', () => {
+  it('should report ANRs as fatal exceptions', async () => {
+    const transport = new MockTransport();
+    const instrumentation = new ANRInstrumentation();
+    const nativeModule = {
+      getANRStatus: jest.fn(() =>
+        Promise.resolve([
+          JSON.stringify({
+            duration: 5000,
+            stacktrace: 'main thread stack',
+            timestamp: 1710000000000,
+            type: 'ANR',
+          }),
+        ])
+      ),
+    };
+
+    initializeFaro(
+      mockConfig({
+        transports: [transport],
+        instrumentations: [instrumentation],
+      })
+    );
+
+    await (
+      instrumentation as unknown as {
+        checkANRStatus: (nativeModule: typeof nativeModule) => Promise<void>;
+      }
+    ).checkANRStatus(nativeModule);
+
+    const item = transport.items.find((transportItem) => {
+      return (transportItem.payload as { type?: string }).type === 'ANR';
+    }) as TransportItem<ExceptionEvent>;
+
+    expect(item.payload.type).toBe('ANR');
+    expect(item.payload.fatal).toBe(true);
+    expect(item.payload.context?.mechanism).toBe('anr');
+    expect(item.payload.context?.stacktrace).toBe('main thread stack');
+  });
+});