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

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

@@ -0,0 +1,407 @@
+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
+jest.mock('react-native-device-info', () => ({
+  getUniqueId: jest.fn(),
+  getSystemName: jest.fn(),
+  getSystemVersion: jest.fn(),
+  getManufacturerSync: jest.fn(),
+  getModel: jest.fn(),
+  getDeviceNameSync: jest.fn(),
+  getBrand: jest.fn(),
+  isEmulatorSync: jest.fn(),
+  isTablet: jest.fn(),
+  getTotalMemorySync: jest.fn(),
+  getUsedMemorySync: jest.fn(),
+  getBatteryLevel: jest.fn(),
+  isBatteryCharging: jest.fn(),
+  getCarrier: jest.fn(),
+  getApiLevel: jest.fn(),
+}));
+
+describe('sessionAttributes', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getSessionAttributes', () => {
+    describe('iOS', () => {
+      beforeEach(() => {
+        // Mock iOS platform
+        (Platform as any).OS = 'ios';
+        Object.defineProperty(Platform, 'constants', {
+          value: {
+            reactNativeVersion: {
+              major: 0,
+              minor: 75,
+              patch: 1,
+            },
+          },
+          writable: true,
+        });
+      });
+
+      it('should collect all iOS device attributes', async () => {
+        // Setup mocks for iOS device
+        (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('ios-device-uuid-123');
+        (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);
+        (DeviceInfo.isTablet as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.getTotalMemorySync as jest.Mock).mockReturnValue(4000000000);
+        (DeviceInfo.getUsedMemorySync as jest.Mock).mockReturnValue(2000000000);
+        (DeviceInfo.getBatteryLevel as jest.Mock).mockResolvedValue(0.85);
+        (DeviceInfo.isBatteryCharging as jest.Mock).mockResolvedValue(false);
+        (DeviceInfo.getCarrier as jest.Mock).mockResolvedValue('Verizon');
+
+        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',
+          device_os_detail: 'iOS 17.0',
+          device_manufacturer: 'apple',
+          device_model: 'iPhone16,1',
+          device_model_name: 'iPhone 15 Pro',
+          device_brand: 'Apple',
+          device_is_physical: 'true',
+          device_id: 'ios-device-uuid-123',
+          device_type: 'mobile',
+          device_memory_total: '4000000000',
+          device_memory_used: '2000000000',
+          device_battery_level: '85',
+          device_is_charging: 'false',
+          device_low_power_mode: undefined,
+          device_carrier: 'Verizon',
+        });
+      });
+
+      it('should identify emulator devices', async () => {
+        (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('emulator-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('x86_64');
+        (DeviceInfo.getDeviceNameSync as jest.Mock).mockReturnValue('iPhone Simulator');
+        (DeviceInfo.getBrand as jest.Mock).mockReturnValue('Apple');
+        (DeviceInfo.isEmulatorSync as jest.Mock).mockReturnValue(true);
+        (DeviceInfo.isTablet as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.getTotalMemorySync as jest.Mock).mockReturnValue(2000000000);
+        (DeviceInfo.getUsedMemorySync as jest.Mock).mockReturnValue(1000000000);
+
+        const attributes = await getSessionAttributes();
+
+        expect(attributes.device_is_physical).toBe('false');
+        expect(attributes.device_model_name).toBe('iPhone Simulator');
+      });
+
+      it('should handle iOS with different OS versions', async () => {
+        (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('device-uuid');
+        (DeviceInfo.getSystemName as jest.Mock).mockReturnValue('iOS');
+        (DeviceInfo.getSystemVersion as jest.Mock).mockReturnValue('16.4');
+        (DeviceInfo.getManufacturerSync as jest.Mock).mockReturnValue('Apple');
+        (DeviceInfo.getModel as jest.Mock).mockReturnValue('iPhone15,2');
+        (DeviceInfo.getDeviceNameSync as jest.Mock).mockReturnValue('iPhone 14 Pro');
+        (DeviceInfo.getBrand as jest.Mock).mockReturnValue('Apple');
+        (DeviceInfo.isEmulatorSync as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.isTablet as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.getTotalMemorySync as jest.Mock).mockReturnValue(6000000000);
+        (DeviceInfo.getUsedMemorySync as jest.Mock).mockReturnValue(3000000000);
+
+        const attributes = await getSessionAttributes();
+
+        expect(attributes.device_os_version).toBe('16.4');
+        expect(attributes.device_os_detail).toBe('iOS 16.4');
+      });
+    });
+
+    describe('Android', () => {
+      beforeEach(() => {
+        // Mock Android platform
+        (Platform as any).OS = 'android';
+        Object.defineProperty(Platform, 'constants', {
+          value: {
+            reactNativeVersion: {
+              major: 0,
+              minor: 75,
+              patch: 1,
+            },
+          },
+          writable: true,
+        });
+      });
+
+      it('should collect all Android device attributes', async () => {
+        // Setup mocks for Android device
+        (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('android-device-uuid-456');
+        (DeviceInfo.getSystemName as jest.Mock).mockReturnValue('Android');
+        (DeviceInfo.getSystemVersion as jest.Mock).mockReturnValue('15');
+        (DeviceInfo.getManufacturerSync as jest.Mock).mockReturnValue('Samsung');
+        (DeviceInfo.getModel as jest.Mock).mockReturnValue('SM-A155F');
+        (DeviceInfo.getDeviceNameSync as jest.Mock).mockReturnValue('SM-A155F');
+        (DeviceInfo.getBrand as jest.Mock).mockReturnValue('samsung');
+        (DeviceInfo.isEmulatorSync as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.isTablet as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.getTotalMemorySync as jest.Mock).mockReturnValue(8000000000);
+        (DeviceInfo.getUsedMemorySync as jest.Mock).mockReturnValue(4000000000);
+        (DeviceInfo.getBatteryLevel as jest.Mock).mockResolvedValue(0.85);
+        (DeviceInfo.isBatteryCharging as jest.Mock).mockResolvedValue(false);
+        (DeviceInfo.getCarrier as jest.Mock).mockResolvedValue('Verizon');
+        (DeviceInfo.getApiLevel as jest.Mock).mockResolvedValue(35);
+
+        const attributes = await getSessionAttributes();
+
+        expect(attributes).toEqual({
+          faro_sdk_version: VERSION,
+          react_native_version: '0.75.1',
+          device_os: 'Android',
+          device_os_version: '15',
+          device_os_detail: 'Android 15 (SDK 35)',
+          device_manufacturer: 'samsung',
+          device_model: 'SM-A155F',
+          device_model_name: 'SM-A155F',
+          device_brand: 'samsung',
+          device_is_physical: 'true',
+          device_id: 'android-device-uuid-456',
+          device_type: 'mobile',
+          device_memory_total: '8000000000',
+          device_memory_used: '4000000000',
+          device_battery_level: '85',
+          device_is_charging: 'false',
+          device_low_power_mode: undefined,
+          device_carrier: 'Verizon',
+        });
+      });
+
+      it('should identify Android emulator devices', async () => {
+        (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('emulator-uuid');
+        (DeviceInfo.getSystemName as jest.Mock).mockReturnValue('Android');
+        (DeviceInfo.getSystemVersion as jest.Mock).mockReturnValue('13');
+        (DeviceInfo.getManufacturerSync as jest.Mock).mockReturnValue('Google');
+        (DeviceInfo.getModel as jest.Mock).mockReturnValue('sdk_gphone64_arm64');
+        (DeviceInfo.getDeviceNameSync as jest.Mock).mockReturnValue('Pixel 5');
+        (DeviceInfo.getBrand as jest.Mock).mockReturnValue('google');
+        (DeviceInfo.isEmulatorSync as jest.Mock).mockReturnValue(true);
+        (DeviceInfo.isTablet as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.getTotalMemorySync as jest.Mock).mockReturnValue(2000000000);
+        (DeviceInfo.getUsedMemorySync as jest.Mock).mockReturnValue(1000000000);
+        (DeviceInfo.getApiLevel as jest.Mock).mockResolvedValue(33);
+
+        const attributes = await getSessionAttributes();
+
+        expect(attributes.device_is_physical).toBe('false');
+        expect(attributes.device_model).toBe('sdk_gphone64_arm64');
+      });
+
+      it('should handle Android without API level', async () => {
+        (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('device-uuid');
+        (DeviceInfo.getSystemName as jest.Mock).mockReturnValue('Android');
+        (DeviceInfo.getSystemVersion as jest.Mock).mockReturnValue('12');
+        (DeviceInfo.getManufacturerSync as jest.Mock).mockReturnValue('Xiaomi');
+        (DeviceInfo.getModel as jest.Mock).mockReturnValue('M2101K7AG');
+        (DeviceInfo.getDeviceNameSync as jest.Mock).mockReturnValue('M2101K7AG');
+        (DeviceInfo.getBrand as jest.Mock).mockReturnValue('xiaomi');
+        (DeviceInfo.isEmulatorSync as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.isTablet as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.getTotalMemorySync as jest.Mock).mockReturnValue(6000000000);
+        (DeviceInfo.getUsedMemorySync as jest.Mock).mockReturnValue(3000000000);
+        (DeviceInfo.getApiLevel as jest.Mock).mockRejectedValue(new Error('API level unavailable'));
+
+        const attributes = await getSessionAttributes();
+
+        // Should fallback to version without SDK level
+        expect(attributes.device_os_detail).toBe('Android 12');
+      });
+    });
+
+    describe('React Native version parsing', () => {
+      it('should parse version with prerelease', () => {
+        Object.defineProperty(Platform, 'constants', {
+          value: {
+            reactNativeVersion: {
+              major: 0,
+              minor: 76,
+              patch: 0,
+              prerelease: 1,
+            },
+          },
+          writable: true,
+        });
+
+        (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);
+
+        return getSessionAttributes().then((attributes) => {
+          expect(attributes.react_native_version).toBe('0.76.0-rc.1');
+        });
+      });
+
+      it('should fallback to unknown if version unavailable', () => {
+        Object.defineProperty(Platform, 'constants', {
+          value: {},
+          writable: true,
+        });
+
+        (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);
+
+        return getSessionAttributes().then((attributes) => {
+          expect(attributes.react_native_version).toBe('unknown');
+        });
+      });
+    });
+
+    describe('Error handling', () => {
+      it('should gracefully handle DeviceInfo errors and return fallback values', async () => {
+        // Mock all DeviceInfo methods to throw errors
+        (DeviceInfo.getUniqueId as jest.Mock).mockRejectedValue(new Error('Failed to get UUID'));
+        (DeviceInfo.getSystemName as jest.Mock).mockImplementation(() => {
+          throw new Error('Failed to get system name');
+        });
+        (DeviceInfo.getSystemVersion as jest.Mock).mockImplementation(() => {
+          throw new Error('Failed to get system version');
+        });
+        (DeviceInfo.getManufacturerSync as jest.Mock).mockImplementation(() => {
+          throw new Error('Failed to get manufacturer');
+        });
+        (DeviceInfo.getModel as jest.Mock).mockImplementation(() => {
+          throw new Error('Failed to get model');
+        });
+        (DeviceInfo.getDeviceNameSync as jest.Mock).mockImplementation(() => {
+          throw new Error('Failed to get device name');
+        });
+        (DeviceInfo.getBrand as jest.Mock).mockImplementation(() => {
+          throw new Error('Failed to get brand');
+        });
+        (DeviceInfo.isEmulatorSync as jest.Mock).mockImplementation(() => {
+          throw new Error('Failed to check emulator');
+        });
+
+        const attributes = await getSessionAttributes();
+
+        // Should return minimal attributes with fallbacks
+        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',
+        });
+      });
+
+      it('should handle partial DeviceInfo failures', async () => {
+        // Some methods work, others fail
+        // Note: If any method throws, the entire catch block returns fallback values
+        (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('valid-uuid');
+        (DeviceInfo.getSystemName as jest.Mock).mockReturnValue('iOS');
+        (DeviceInfo.getSystemVersion as jest.Mock).mockReturnValue('17.0');
+        (DeviceInfo.getManufacturerSync as jest.Mock).mockImplementation(() => {
+          throw new Error('Manufacturer unavailable');
+        });
+        (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();
+
+        // 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');
+      });
+    });
+
+    describe('Manufacturer normalization', () => {
+      it('should lowercase manufacturer names', async () => {
+        (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('uuid');
+        (DeviceInfo.getSystemName as jest.Mock).mockReturnValue('Android');
+        (DeviceInfo.getSystemVersion as jest.Mock).mockReturnValue('14');
+        (DeviceInfo.getManufacturerSync as jest.Mock).mockReturnValue('SAMSUNG');
+        (DeviceInfo.getModel as jest.Mock).mockReturnValue('SM-G998B');
+        (DeviceInfo.getDeviceNameSync as jest.Mock).mockReturnValue('Galaxy S21 Ultra');
+        (DeviceInfo.getBrand as jest.Mock).mockReturnValue('samsung');
+        (DeviceInfo.isEmulatorSync as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.isTablet as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.getTotalMemorySync as jest.Mock).mockReturnValue(12000000000);
+        (DeviceInfo.getUsedMemorySync as jest.Mock).mockReturnValue(6000000000);
+        (DeviceInfo.getApiLevel as jest.Mock).mockResolvedValue(34);
+
+        const attributes = await getSessionAttributes();
+
+        expect(attributes.device_manufacturer).toBe('samsung');
+      });
+
+      it('should handle mixed case manufacturer names', async () => {
+        (DeviceInfo.getUniqueId as jest.Mock).mockResolvedValue('uuid');
+        (DeviceInfo.getSystemName as jest.Mock).mockReturnValue('Android');
+        (DeviceInfo.getSystemVersion as jest.Mock).mockReturnValue('14');
+        (DeviceInfo.getManufacturerSync as jest.Mock).mockReturnValue('OnePlus');
+        (DeviceInfo.getModel as jest.Mock).mockReturnValue('LE2121');
+        (DeviceInfo.getDeviceNameSync as jest.Mock).mockReturnValue('OnePlus 9 Pro');
+        (DeviceInfo.getBrand as jest.Mock).mockReturnValue('OnePlus');
+        (DeviceInfo.isEmulatorSync as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.isTablet as jest.Mock).mockReturnValue(false);
+        (DeviceInfo.getTotalMemorySync as jest.Mock).mockReturnValue(8000000000);
+        (DeviceInfo.getUsedMemorySync as jest.Mock).mockReturnValue(4000000000);
+        (DeviceInfo.getApiLevel as jest.Mock).mockResolvedValue(34);
+
+        const attributes = await getSessionAttributes();
+
+        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

@@ -0,0 +1,250 @@
+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.)
+ */
+export interface SessionAttributes {
+  /** SDK version (e.g., "2.0.2") */
+  faro_sdk_version: string;
+
+  /** React Native version (e.g., "0.75.1") */
+  react_native_version: string;
+
+  /** Operating system ("iOS" or "Android") */
+  device_os: string;
+
+  /** OS version (e.g., "17.0" for iOS, "15" for Android) */
+  device_os_version: string;
+
+  /** Detailed OS info (e.g., "iOS 17.0" or "Android 15 (SDK 35)") */
+  device_os_detail: string;
+
+  /** Device manufacturer (e.g., "apple", "samsung") */
+  device_manufacturer: string;
+
+  /** Raw model identifier (e.g., "iPhone16,1", "SM-A155F") */
+  device_model: string;
+
+  /** Human-readable model name (e.g., "iPhone 15 Pro") */
+  device_model_name: string;
+
+  /** Device brand (e.g., "iPhone", "samsung") */
+  device_brand: string;
+
+  /** Whether device is physical or emulator ("true" or "false") */
+  device_is_physical: string;
+
+  /** Unique device ID (UUID) */
+  device_id: string;
+
+  /** Device type ("mobile" or "tablet") */
+  device_type: string;
+
+  /** Total device memory in bytes */
+  device_memory_total: string;
+
+  /** Currently used memory in bytes */
+  device_memory_used: string;
+
+  /** Battery level percentage (e.g., "85") - empty if unavailable */
+  device_battery_level?: string;
+
+  /** Whether device is charging ("true" or "false") - empty if unavailable */
+  device_is_charging?: string;
+
+  /** Whether low power mode is enabled ("true" or "false") - empty if unavailable */
+  device_low_power_mode?: string;
+
+  /** Mobile carrier name (e.g., "Verizon") - empty if unavailable */
+  device_carrier?: string;
+}
+
+/**
+ * Get React Native version from Platform
+ * Returns "unknown" if not available
+ */
+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 {
+        major: number;
+        minor: number;
+        patch: number;
+        prerelease?: number;
+      };
+      let versionString = `${major}.${minor}.${patch}`;
+      if (prerelease) {
+        versionString += `-rc.${prerelease}`;
+      }
+      return versionString;
+    }
+    return 'unknown';
+  } catch (_error) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Get device ID using react-native-device-info
+ * Returns unique device identifier or 'unknown' on error
+ */
+async function getDeviceId(): Promise<string> {
+  try {
+    // getUniqueId returns a UUID that persists across app installations
+    return await DeviceInfo.getUniqueId();
+  } catch (_error) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Get OS detail string matching Flutter SDK format
+ * iOS: "iOS 17.0"
+ * Android: "Android 15 (SDK 35)"
+ */
+async function getDeviceOsDetail(): Promise<string> {
+  const systemName = DeviceInfo.getSystemName();
+  const systemVersion = DeviceInfo.getSystemVersion();
+
+  if (Platform.OS === 'android') {
+    try {
+      const apiLevel = await DeviceInfo.getApiLevel();
+      return `${systemName} ${systemVersion} (SDK ${apiLevel})`;
+    } catch (_error) {
+      return `${systemName} ${systemVersion}`;
+    }
+  }
+
+  return `${systemName} ${systemVersion}`;
+}
+
+/**
+ * Get all session attributes
+ * These attributes are automatically included with every telemetry event
+ *
+ * Core attributes matching Flutter SDK:
+ * - faro_sdk_version, react_native_version
+ * - device_os, device_os_version, device_os_detail
+ * - device_manufacturer, device_model, device_model_name
+ * - device_brand, device_is_physical, device_id
+ *
+ * Additional monitoring attributes:
+ * - device_type (mobile/tablet)
+ * - device_memory_total, device_memory_used
+ * - device_battery_level, device_is_charging, device_low_power_mode
+ * - device_carrier
+ */
+export async function getSessionAttributes(): Promise<SessionAttributes> {
+  try {
+    // Get device ID asynchronously
+    const deviceId = await getDeviceId();
+    const deviceOsDetail = await getDeviceOsDetail();
+
+    // Get synchronous device info
+    const systemName = DeviceInfo.getSystemName();
+    const systemVersion = DeviceInfo.getSystemVersion();
+    const manufacturer = DeviceInfo.getManufacturerSync();
+    const model = DeviceInfo.getModel();
+    const deviceName = DeviceInfo.getDeviceNameSync();
+    const brand = DeviceInfo.getBrand();
+    const isEmulator = DeviceInfo.isEmulatorSync();
+    const isTablet = DeviceInfo.isTablet();
+
+    // 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)
+    let batteryLevel: string | undefined;
+    let isCharging: string | undefined;
+    let lowPowerMode: string | undefined;
+    let carrier: string | undefined;
+
+    try {
+      const battery = await DeviceInfo.getBatteryLevel();
+      if (battery >= 0) {
+        batteryLevel = String(Math.round(battery * 100));
+      }
+    } catch (_error) {
+      // Battery info not available
+    }
+
+    try {
+      isCharging = String(await DeviceInfo.isBatteryCharging());
+    } catch (_error) {
+      // Charging status not available
+    }
+
+    try {
+      if ('isPowerSaveMode' in DeviceInfo) {
+        lowPowerMode = String(
+          await (DeviceInfo as typeof DeviceInfo & { isPowerSaveMode: () => Promise<boolean> }).isPowerSaveMode()
+        );
+      }
+    } catch (_error) {
+      // Low power mode not available
+    }
+
+    try {
+      const carrierName = await DeviceInfo.getCarrier();
+      if (carrierName && carrierName !== 'unknown') {
+        carrier = carrierName;
+      }
+    } catch (_error) {
+      // Carrier not available
+    }
+
+    const attributes: SessionAttributes = {
+      faro_sdk_version: VERSION,
+      react_native_version: reactNativeVersion,
+      device_os: systemName,
+      device_os_version: systemVersion,
+      device_os_detail: deviceOsDetail,
+      device_manufacturer: manufacturer.toLowerCase(),
+      device_model: model,
+      device_model_name: deviceName,
+      device_brand: brand,
+      device_is_physical: String(!isEmulator),
+      device_id: deviceId,
+      device_type: isTablet ? 'tablet' : 'mobile',
+      device_memory_total: String(totalMemory),
+      device_memory_used: String(usedMemory),
+      device_battery_level: batteryLevel,
+      device_is_charging: isCharging,
+      device_low_power_mode: lowPowerMode,
+      device_carrier: carrier,
+    };
+
+    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',
+    };
+  }
+}