react-native-inapp-inspector 2.3.14 → 2.3.16

package/dist/esm/helpers/telemetry.js

@@ -1,6 +1,13 @@
-import { Platform } from 'react-native';
+import React from 'react';
+import { Appearance, Dimensions, PixelRatio, Platform, NativeModules } from 'react-native';
 import { LIB_VERSION } from '../constants/version';
 import { loadSettings, saveSettings } from './settingsStore';
+import { isReduxConnected } from '../customHooks/reduxLogger';
+import { isFirebaseAnalyticsPatched } from '../customHooks/analyticsLogger';
+import { getCrashRecords } from '../customHooks/crashHandler';
+import { getNetworkLogs } from '../customHooks/networkLogger';
+import { isNativeModuleAvailable } from '../native/NativeInspector';
+import { getAppName, getBundleIdentifier, getAppVersionAndBuild, isLocalDebugEnvironment, } from './index';
 import { ENC_MID, ENC_SEC, TELEMETRY_SALT, } from '../constants/telemetryConfig';
 const PKG_NAME = 'react-native-inapp-inspector';
 const KEY_MATERIAL = `${PKG_NAME}::${TELEMETRY_SALT}`;
@@ -60,19 +67,33 @@ function getCollectUrl() {
 }
 const PING_INTERVAL_MS = 24 * 60 * 60 * 1000;
 let isTelemetryEnabled = true;
+let _hasSearchFilterBeenUsed = false;
 export function setTelemetryEnabled(enabled) {
     isTelemetryEnabled = enabled;
 }
+export function markSearchFilterUsed() {
+    _hasSearchFilterBeenUsed = true;
+}
 async function getOrCreateClientId() {
     try {
         const settings = await loadSettings();
-        if (settings.telemetryClientId) {
-            return settings.telemetryClientId;
+        if (settings.telemetryClientId || settings.telemetryDeviceId) {
+            const id = settings.telemetryClientId || settings.telemetryDeviceId || '';
+            if (!settings.telemetryDeviceId) {
+                await saveSettings({ ...settings, telemetryDeviceId: id });
+            }
+            return id;
         }
         const part1 = Math.floor(100000000 + Math.random() * 900000000);
         const part2 = Math.floor(1000000000 + Math.random() * 9000000000);
         const newId = `${part1}.${part2}`;
-        saveSettings({ ...settings, telemetryClientId: newId });
+        const now = Date.now();
+        await saveSettings({
+            ...settings,
+            telemetryClientId: newId,
+            telemetryDeviceId: newId,
+            deviceFirstSeen: settings.deviceFirstSeen || now,
+        });
         return newId;
     }
     catch {
@@ -109,26 +130,181 @@ function isDeviceEmulator() {
     }
     return false;
 }
-function getSystemMetadata(environment) {
+function getDeviceLocaleInfo() {
+    try {
+        const opts = typeof Intl !== 'undefined' && Intl.DateTimeFormat ? Intl.DateTimeFormat().resolvedOptions() : {};
+        const timeZone = opts.timeZone || 'unknown';
+        const locale = opts.locale || 'unknown';
+        let countryCode = 'unknown';
+        if (locale && locale !== 'unknown') {
+            const parts = locale.split(/[-_]/);
+            if (parts.length > 1) {
+                countryCode = parts[parts.length - 1].toUpperCase();
+            }
+        }
+        return { countryCode, locale, timeZone };
+    }
+    catch {
+        return { countryCode: 'unknown', locale: 'unknown', timeZone: 'unknown' };
+    }
+}
+function getSystemMetadata(environment, currentSettings) {
     const rnConstants = Platform.constants;
     const rnVersion = rnConstants?.reactNativeVersion
         ? `${rnConstants.reactNativeVersion.major}.${rnConstants.reactNativeVersion.minor}.${rnConstants.reactNativeVersion.patch}`
         : 'unknown';
     const isHermes = Boolean(typeof global.HermesInternal === 'object' && global.HermesInternal !== null);
     const isFabric = Boolean(global?.nativeFabricUIManager !== undefined);
+    const isBridgeless = Boolean(global?._rn_bridgeless || global?.RN$Bridgeless);
     const isDev = Boolean(typeof __DEV__ !== 'undefined' && __DEV__);
     const isEmulator = isDeviceEmulator();
+    const { countryCode, locale, timeZone } = getDeviceLocaleInfo();
+    let screenRes = 'unknown';
+    let screenDensity = 1;
+    let fontScale = 1;
+    let deviceFormFactor = 'phone';
+    let screenOrientation = 'portrait';
+    try {
+        const dim = Dimensions.get('window');
+        screenRes = `${Math.round(dim.width)}x${Math.round(dim.height)}`;
+        screenDensity = PixelRatio.get();
+        fontScale = PixelRatio.getFontScale();
+        screenOrientation = dim.width > dim.height ? 'landscape' : 'portrait';
+        const isTablet = (Platform.OS === 'ios' && Boolean(Platform.isPad)) ||
+            (Math.min(dim.width, dim.height) >= 600);
+        deviceFormFactor = isTablet ? 'tablet' : 'phone';
+    }
+    catch { }
+    let appearanceMode = 'unknown';
+    try {
+        appearanceMode = Appearance?.getColorScheme?.() || 'unknown';
+    }
+    catch { }
+    const isExpo = Boolean(globalThis?.expo ||
+        globalThis?.__expo ||
+        globalThis?.__turboModuleProxy?.name === 'Expo' ||
+        Platform.constants?.ExpoVersion);
+    let hermesVersion = 'non_hermes';
+    let jsEngine = 'jsc';
+    if (isHermes) {
+        jsEngine = 'hermes';
+        try {
+            const props = global.HermesInternal?.getRuntimeProperties?.() || {};
+            hermesVersion = props['OSS Release Version'] || (props['Bytecode Version'] ? `bc_v${props['Bytecode Version']}` : 'hermes');
+        }
+        catch {
+            hermesVersion = 'hermes';
+        }
+    }
+    else if (globalThis?._v8) {
+        jsEngine = 'v8';
+    }
+    let reduxAttached = false;
+    try {
+        reduxAttached = isReduxConnected();
+    }
+    catch { }
+    let analyticsAttached = false;
+    try {
+        analyticsAttached = isFirebaseAnalyticsPatched();
+    }
+    catch { }
+    const hasNativeModule = isNativeModuleAvailable();
+    const hasMmkv = Boolean(NativeModules?.RNMMKV || globalThis?.MMKV);
+    let capturedCrashesCount = 0;
+    try {
+        capturedCrashesCount = getCrashRecords().length;
+    }
+    catch { }
+    let capturedApisBracket = '0';
+    try {
+        const apiCount = getNetworkLogs().length;
+        capturedApisBracket =
+            apiCount === 0
+                ? '0'
+                : apiCount <= 10
+                    ? '1-10'
+                    : apiCount <= 50
+                        ? '11-50'
+                        : apiCount <= 100
+                            ? '51-100'
+                            : '100+';
+    }
+    catch { }
+    let isMetroConnected = false;
+    try {
+        isMetroConnected = isLocalDebugEnvironment();
+    }
+    catch { }
+    const defaultLandingTab = currentSettings?.defaultTab || 'apis';
+    const fabMode = hasNativeModule && currentSettings?.useNativeFab !== false
+        ? 'native_ui_thread'
+        : 'js_floating_button';
+    const deviceBrand = String(rnConstants?.Brand ||
+        (Platform.OS === 'ios' ? 'Apple' : 'unknown'));
+    const deviceModel = String(rnConstants?.Model ||
+        rnConstants?.systemName ||
+        (Platform.OS === 'ios' ? 'iPhone/iPad' : 'unknown'));
+    const deviceManufacturer = String(rnConstants?.Manufacturer ||
+        (Platform.OS === 'ios' ? 'Apple' : 'unknown'));
+    let appName = 'App';
+    let bundleId = 'unknown';
+    let appVersion = 'unknown';
+    let appBuild = 'unknown';
+    try {
+        appName = getAppName() || 'App';
+        bundleId = getBundleIdentifier() || 'unknown';
+        const verInfo = getAppVersionAndBuild();
+        appVersion = verInfo.version || 'unknown';
+        appBuild = verInfo.build || 'unknown';
+    }
+    catch { }
+    const reactVer = typeof React !== 'undefined' && React.version ? React.version : 'unknown';
     return {
+        pkg_name: PKG_NAME,
+        pkg_version: LIB_VERSION,
         lib_version: LIB_VERSION,
+        install_type: isDev ? 'local_dev' : 'bundled_production',
+        app_name: appName,
+        bundle_id: bundleId,
+        app_version: appVersion,
+        app_build: appBuild,
+        react_version: reactVer,
         platform: Platform.OS,
         os_version: String(Platform.Version || 'unknown'),
         rn_version: rnVersion,
+        country_code: countryCode,
+        device_locale: locale,
+        time_zone: timeZone,
+        device_brand: deviceBrand,
+        device_model: deviceModel,
+        device_manufacturer: deviceManufacturer,
+        device_form_factor: deviceFormFactor,
+        screen_resolution: screenRes,
+        screen_density: screenDensity,
+        screen_orientation: screenOrientation,
+        font_scale: fontScale,
+        appearance_mode: appearanceMode,
+        is_expo: isExpo,
+        js_engine: jsEngine,
+        hermes_version: hermesVersion,
         is_hermes: isHermes,
         is_fabric: isFabric,
+        is_bridgeless: isBridgeless,
+        has_native_module: hasNativeModule,
+        has_mmkv: hasMmkv,
+        fab_mode: fabMode,
+        default_landing_tab: defaultLandingTab,
+        captured_crashes_count: capturedCrashesCount,
+        captured_apis_bracket: capturedApisBracket,
+        search_filter_used: _hasSearchFilterBeenUsed,
+        is_metro_connected: isMetroConnected,
         is_dev: isDev,
         is_emulator: isEmulator,
         device_type: isEmulator ? 'emulator' : 'real_device',
         app_mode: isDev ? 'local_mode' : 'bundled_application',
+        redux_attached: reduxAttached,
+        analytics_attached: analyticsAttached,
         environment: environment || (isDev ? 'DEV' : 'PROD'),
         engagement_time_msec: 1000,
     };
@@ -146,21 +322,168 @@ export async function trackActiveTelemetryHeartbeat(telemetryEnabled = true, env
         const settings = await loadSettings();
         const lastPing = settings.telemetryLastPing || 0;
         const now = Date.now();
-        if (now - lastPing < PING_INTERVAL_MS)
+        const isNewDevice = !settings.deviceRegistered;
+        if (!isNewDevice && now - lastPing < PING_INTERVAL_MS)
             return;
         const clientId = await getOrCreateClientId();
-        const params = getSystemMetadata(environment);
+        const params = getSystemMetadata(environment, settings);
+        const deviceParams = {
+            ...params,
+            device_id: clientId,
+            is_new_device: isNewDevice,
+            device_first_seen: settings.deviceFirstSeen || now,
+        };
+        const eventsToDispatch = isNewDevice
+            ? [
+                { name: 'active_device', params: deviceParams },
+                { name: 'first_device_install', params: deviceParams },
+                { name: 'inspector_active_heartbeat', params: deviceParams },
+            ]
+            : [
+                { name: 'active_device', params: deviceParams },
+                { name: 'inspector_active_heartbeat', params: deviceParams },
+            ];
         await fetch(url, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
                 client_id: clientId,
+                user_id: clientId,
                 non_personalized_ads: true,
-                events: [{ name: 'inspector_active_heartbeat', params }],
+                user_properties: {
+                    device_id: { value: clientId },
+                    pkg_name: { value: params.pkg_name },
+                    pkg_version: { value: params.pkg_version },
+                    install_type: { value: params.install_type },
+                    app_name: { value: params.app_name },
+                    bundle_id: { value: params.bundle_id },
+                    app_version: { value: params.app_version },
+                    react_version: { value: params.react_version },
+                    country: { value: params.country_code },
+                    country_code: { value: params.country_code },
+                    locale: { value: params.device_locale },
+                    time_zone: { value: params.time_zone },
+                    device_brand: { value: params.device_brand },
+                    device_model: { value: params.device_model },
+                    device_form_factor: { value: params.device_form_factor },
+                    screen_resolution: { value: params.screen_resolution },
+                    appearance_mode: { value: params.appearance_mode },
+                    is_expo: { value: String(params.is_expo) },
+                    js_engine: { value: params.js_engine },
+                    is_fabric: { value: String(params.is_fabric) },
+                    is_bridgeless: { value: String(params.is_bridgeless) },
+                    has_native_module: { value: String(params.has_native_module) },
+                    has_mmkv: { value: String(params.has_mmkv) },
+                    fab_mode: { value: params.fab_mode },
+                    default_landing_tab: { value: params.default_landing_tab },
+                    captured_crashes_count: { value: String(params.captured_crashes_count) },
+                    captured_apis_bracket: { value: params.captured_apis_bracket },
+                    search_filter_used: { value: String(params.search_filter_used) },
+                    is_metro_connected: { value: String(params.is_metro_connected) },
+                    redux_attached: { value: String(params.redux_attached) },
+                    analytics_attached: { value: String(params.analytics_attached) },
+                    platform: { value: params.platform },
+                    rn_version: { value: params.rn_version },
+                    lib_version: { value: params.lib_version },
+                },
+                events: eventsToDispatch,
             }),
         });
-        saveSettings({ ...settings, telemetryLastPing: now });
+        await saveSettings({
+            ...settings,
+            telemetryClientId: clientId,
+            telemetryDeviceId: clientId,
+            deviceRegistered: true,
+            deviceFirstSeen: settings.deviceFirstSeen || now,
+            telemetryLastPing: now,
+            telemetryLastActive: now,
+        });
     }
     catch {
     }
 }
+export async function trackTelemetryEvent(eventName, eventParams) {
+    if (!isTelemetryEnabled)
+        return;
+    const url = getCollectUrl();
+    if (!url)
+        return;
+    try {
+        const clientId = await getOrCreateClientId();
+        const settings = await loadSettings().catch(() => ({}));
+        const metadata = getSystemMetadata(undefined, settings);
+        const params = {
+            ...metadata,
+            device_id: clientId,
+            ...eventParams,
+            engagement_time_msec: 100,
+        };
+        await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                client_id: clientId,
+                user_id: clientId,
+                non_personalized_ads: true,
+                user_properties: {
+                    device_id: { value: clientId },
+                    pkg_name: { value: metadata.pkg_name },
+                    pkg_version: { value: metadata.pkg_version },
+                    install_type: { value: metadata.install_type },
+                    app_name: { value: metadata.app_name },
+                    bundle_id: { value: metadata.bundle_id },
+                    app_version: { value: metadata.app_version },
+                    react_version: { value: metadata.react_version },
+                    country: { value: metadata.country_code },
+                    country_code: { value: metadata.country_code },
+                    locale: { value: metadata.device_locale },
+                    time_zone: { value: metadata.time_zone },
+                    device_brand: { value: metadata.device_brand },
+                    device_model: { value: metadata.device_model },
+                    device_form_factor: { value: metadata.device_form_factor },
+                    screen_resolution: { value: metadata.screen_resolution },
+                    appearance_mode: { value: metadata.appearance_mode },
+                    is_expo: { value: String(metadata.is_expo) },
+                    js_engine: { value: metadata.js_engine },
+                    is_fabric: { value: String(metadata.is_fabric) },
+                    is_bridgeless: { value: String(metadata.is_bridgeless) },
+                    has_native_module: { value: String(metadata.has_native_module) },
+                    has_mmkv: { value: String(metadata.has_mmkv) },
+                    fab_mode: { value: metadata.fab_mode },
+                    default_landing_tab: { value: metadata.default_landing_tab },
+                    captured_crashes_count: { value: String(metadata.captured_crashes_count) },
+                    captured_apis_bracket: { value: metadata.captured_apis_bracket },
+                    search_filter_used: { value: String(metadata.search_filter_used) },
+                    is_metro_connected: { value: String(metadata.is_metro_connected) },
+                    redux_attached: { value: String(metadata.redux_attached) },
+                    analytics_attached: { value: String(metadata.analytics_attached) },
+                    platform: { value: metadata.platform },
+                    rn_version: { value: metadata.rn_version },
+                    lib_version: { value: metadata.lib_version },
+                },
+                events: [{ name: eventName, params }],
+            }),
+        });
+    }
+    catch {
+    }
+}
+export function trackInspectorTabView(tabName) {
+    trackTelemetryEvent('inspector_tab_view', {
+        tab_name: tabName,
+        screen_name: `tab_${tabName}`,
+        screen_class: 'NetworkInspector',
+    });
+}
+export function trackInspectorScreenView(screenName) {
+    trackTelemetryEvent('screen_view', {
+        screen_name: screenName,
+        screen_class: 'NetworkInspector',
+    });
+}
+export function trackInspectorScreenRecord(action, recordingType = 'screen') {
+    trackTelemetryEvent('inspector_screen_record', {
+        action,
+        recording_type: recordingType,
+    });
+}

package/dist/esm/index.d.ts

@@ -26,4 +26,5 @@ export { ActiveTab, Method, StatusFilter, SortOrder, LocalFilter, ModalAnimation
 export { AppFonts, setAppFonts, type AppFontConfig, } from './styles/AppFonts';
 export { AppColors, setAppColors, getThemeColors, updateAppColorsTheme, } from './styles/AppColors';
 export { t, i18n, useTranslation, setLanguage, addTranslations, setTranslations, I18nextProvider, } from './i18n';
+export { fetchRemoteConfigModuleStatus, isFirebaseRemoteConfigAvailable, } from './helpers/remoteConfig';
 export { LIB_VERSION } from './constants/version';