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

package/android/src/main/java/com/grafana/faro/reactnative/FrameMonitor.kt

@@ -0,0 +1,253 @@
+package com.grafana.faro.reactnative
+
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.view.Choreographer
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * Frame monitoring implementation using Choreographer.
+ *
+ * Implementation ported from Faro Flutter SDK's FaroPlugin.java.
+ *
+ * Uses Choreographer.FrameCallback to measure actual frame durations
+ * and detect slow/frozen frames.
+ */
+object FrameMonitor {
+    private const val TAG = "FrameMonitor"
+    private const val NANOSECONDS_IN_SECOND = 1_000_000_000L
+    private const val NANOSECONDS_IN_MILLISECOND = 1_000_000L
+
+    // Throttle refresh rate emits to avoid flooding the JS bridge (was ~60/sec).
+    // Aligns with refreshRatePollingInterval (30s) on iOS and Flutter SDK.
+    private const val REFRESH_RATE_EMIT_INTERVAL_MS = 30_000L
+
+    // Configuration
+    private var targetFps: Double = 60.0
+    private var frozenFrameThresholdNs: Long = 100 * NANOSECONDS_IN_MILLISECOND
+    private var normalizedRefreshRate: Double = 60.0
+
+    // State
+    private var lastFrameTimeNanos: Long = 0
+    private var lastRefreshRate: Double = 0.0
+    private var lastRefreshRateEmitTimeMs: Long = 0
+    private val slowFrameEventCount = AtomicInteger(0)
+    private val frozenFrameCount = AtomicInteger(0)
+    private var frozenFrameDurationMs: Double = 0.0
+    private val isMonitoring = AtomicBoolean(false)
+
+    // Slow frame event detection
+    private var inSlowFrameEvent: Boolean = false
+    private var slowFrameEventStartTimeNanos: Long = 0
+    // Minimum duration (in nanoseconds) for a slow frame event to be counted (~3 frames at 60fps)
+    private val slowFrameEventMinDurationNs: Long = 50 * NANOSECONDS_IN_MILLISECOND
+
+    // Callbacks
+    private var frameCallback: Choreographer.FrameCallback? = null
+    private var onSlowFrames: ((Int) -> Unit)? = null
+    private var onFrozenFrame: ((Int, Double) -> Unit)? = null
+    private var onRefreshRate: ((Double) -> Unit)? = null
+
+    /**
+     * Configure monitoring parameters.
+     *
+     * @param targetFps Target FPS for slow frame detection (default 60)
+     * @param frozenFrameThresholdMs Threshold in ms for frozen frames (default 100)
+     * @param normalizedRefreshRate Normalized rate for high-refresh displays (default 60)
+     */
+    fun configure(
+        targetFps: Double = 60.0,
+        frozenFrameThresholdMs: Double = 100.0,
+        normalizedRefreshRate: Double = 60.0
+    ) {
+        this.targetFps = targetFps
+        this.frozenFrameThresholdNs = (frozenFrameThresholdMs * NANOSECONDS_IN_MILLISECOND).toLong()
+        this.normalizedRefreshRate = normalizedRefreshRate
+    }
+
+    /**
+     * Set callbacks for frame events.
+     */
+    fun setCallbacks(
+        onSlowFrames: ((Int) -> Unit)? = null,
+        onFrozenFrame: ((Int, Double) -> Unit)? = null,
+        onRefreshRate: ((Double) -> Unit)? = null
+    ) {
+        this.onSlowFrames = onSlowFrames
+        this.onFrozenFrame = onFrozenFrame
+        this.onRefreshRate = onRefreshRate
+    }
+
+    /**
+     * Start frame monitoring.
+     */
+    fun start() {
+        if (isMonitoring.get()) return
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+            isMonitoring.set(true)
+            lastFrameTimeNanos = 0
+            lastRefreshRateEmitTimeMs = 0
+            slowFrameEventCount.set(0)
+            frozenFrameCount.set(0)
+            frozenFrameDurationMs = 0.0
+            inSlowFrameEvent = false
+            slowFrameEventStartTimeNanos = 0
+
+            frameCallback = object : Choreographer.FrameCallback {
+                override fun doFrame(frameTimeNanos: Long) {
+                    if (isMonitoring.get()) {
+                        checkFrameDuration(frameTimeNanos)
+                        Choreographer.getInstance().postFrameCallback(this)
+                    }
+                }
+            }
+
+            Handler(Looper.getMainLooper()).post {
+                Choreographer.getInstance().postFrameCallback(frameCallback!!)
+            }
+        }
+    }
+
+    /**
+     * Stop frame monitoring.
+     */
+    fun stop() {
+        isMonitoring.set(false)
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN && frameCallback != null) {
+            Handler(Looper.getMainLooper()).post {
+                try {
+                    Choreographer.getInstance().removeFrameCallback(frameCallback!!)
+                } catch (_: Exception) {
+                    // Ignore errors during cleanup
+                }
+            }
+            frameCallback = null
+        }
+
+        // Reset state
+        lastFrameTimeNanos = 0
+        slowFrameEventCount.set(0)
+        frozenFrameCount.set(0)
+        frozenFrameDurationMs = 0.0
+    }
+
+    /**
+     * Get current refresh rate.
+     */
+    fun getRefreshRate(): Double {
+        return lastRefreshRate
+    }
+
+    /**
+     * Get and reset slow frame event count.
+     */
+    fun getAndResetSlowFrames(): Int {
+        val count = slowFrameEventCount.getAndSet(0)
+        return count
+    }
+
+    /**
+     * Get and reset frozen frame count.
+     */
+    fun getAndResetFrozenFrames(): Int {
+        return frozenFrameCount.getAndSet(0)
+    }
+
+    /**
+     * Get and reset frozen frame duration in milliseconds.
+     */
+    @Synchronized
+    fun getAndResetFrozenDuration(): Double {
+        val duration = frozenFrameDurationMs
+        frozenFrameDurationMs = 0.0
+        return duration
+    }
+
+    /**
+     * Check if monitoring is active.
+     */
+    fun isMonitoring(): Boolean {
+        return isMonitoring.get()
+    }
+
+    private fun checkFrameDuration(frameTimeNanos: Long) {
+        if (lastFrameTimeNanos == 0L) {
+            lastFrameTimeNanos = frameTimeNanos
+            return
+        }
+
+        val frameDuration = frameTimeNanos - lastFrameTimeNanos
+        if (frameDuration <= 0) {
+            lastFrameTimeNanos = frameTimeNanos
+            return
+        }
+
+        // Calculate refresh rate
+        val fps = NANOSECONDS_IN_SECOND.toDouble() / frameDuration
+        lastRefreshRate = fps
+
+        // Throttle: only emit refresh rate every 30 seconds to avoid flooding
+        val nowMs = System.currentTimeMillis()
+        val refreshRateCallback = onRefreshRate
+        if (refreshRateCallback != null && nowMs - lastRefreshRateEmitTimeMs >= REFRESH_RATE_EMIT_INTERVAL_MS) {
+            lastRefreshRateEmitTimeMs = nowMs
+            refreshRateCallback.invoke(fps)
+        }
+
+        // Check for slow frames using event-based detection
+        // A slow frame "event" is a period of consecutive frames below target FPS
+        // This groups consecutive slow frames to report meaningful jank, not microsecond variations
+        val isSlow = fps < targetFps
+        if (isSlow) {
+            android.util.Log.d(TAG, "[Faro DEBUG ANDROID] 🐌 Slow frame detected: %.1f FPS (target: %.1f)".format(fps, targetFps))
+        }
+        
+        if (isSlow) {
+            if (!inSlowFrameEvent) {
+                // Start new slow frame event
+                inSlowFrameEvent = true
+                slowFrameEventStartTimeNanos = frameTimeNanos
+            }
+        } else {
+            // Frame is good - check if we should end the current slow frame event
+            if (inSlowFrameEvent) {
+                val eventDurationNs = frameTimeNanos - slowFrameEventStartTimeNanos
+                val eventDurationMs = eventDurationNs / NANOSECONDS_IN_MILLISECOND
+                val thresholdMs = slowFrameEventMinDurationNs / NANOSECONDS_IN_MILLISECOND
+                
+                // Only count as a slow frame event if it lasted long enough to be user-perceptible
+                // This filters out single-frame dips that don't affect user experience
+                if (eventDurationNs >= slowFrameEventMinDurationNs) {
+                    val newCount = slowFrameEventCount.incrementAndGet()
+                    // 🔍 TEMP DEBUG LOG - Remove after analysis
+                    android.util.Log.d(TAG, "[Faro DEBUG ANDROID] ✅ COUNTED as event (${eventDurationMs}ms)! Total events now: $newCount")
+                } else {
+                    // 🔍 TEMP DEBUG LOG - Remove after analysis
+                    android.util.Log.d(TAG, "[Faro DEBUG ANDROID] ❌ NOT counted (${eventDurationMs}ms is too short). Total events still: ${slowFrameEventCount.get()}")
+                }
+                
+                inSlowFrameEvent = false
+                slowFrameEventStartTimeNanos = 0
+            }
+        }
+
+        // Check for frozen frames (frame duration exceeds threshold)
+        if (frameDuration > frozenFrameThresholdNs) {
+            val count = frozenFrameCount.incrementAndGet()
+            val durationMs = frameDuration.toDouble() / NANOSECONDS_IN_MILLISECOND
+            
+            // Track duration (synchronized to avoid race conditions)
+            synchronized(this) {
+                frozenFrameDurationMs += durationMs
+            }
+            
+            onFrozenFrame?.invoke(count, durationMs)
+        }
+
+        lastFrameTimeNanos = frameTimeNanos
+    }
+}

package/android/src/main/java/com/grafana/faro/reactnative/MemoryInfo.kt

@@ -0,0 +1,61 @@
+package com.grafana.faro.reactnative
+
+import android.os.Process
+import java.io.BufferedReader
+import java.io.File
+import java.io.FileReader
+import java.util.regex.Pattern
+
+/**
+ * Memory usage monitoring for Android
+ *
+ * Uses /proc/[pid]/status file parsing to track memory usage (VmRSS).
+ * Returns instantaneous memory usage in kilobytes.
+ *
+ * Implementation ported from Faro Flutter SDK:
+ * https://github.com/grafana/faro-flutter-sdk/blob/main/android/src/main/java/com/grafana/faro/MemoryUsageInfo.java
+ *
+ * TODO: Currently not tested in demo app due to Yarn workspace gradle path resolution issues.
+ * See demo-react-native/android/settings.gradle for details. This code is complete and ready
+ * to work in standalone React Native projects or once workspace gradle config is fixed.
+ */
+object MemoryInfo {
+
+    // Regex pattern to match VmRSS line in /proc/[pid]/status
+    // Example line: "VmRSS:     12345 kB"
+    private val vmRssPattern = Pattern.compile("VmRSS:\\s+(\\d+) kB")
+
+    /**
+     * Gets current memory usage in kilobytes
+     *
+     * Reads VmRSS (Virtual Memory Resident Set Size) from /proc/[pid]/status.
+     * This represents the actual physical memory currently used by the process.
+     *
+     * @return Memory usage in KB, or null on error
+     */
+    fun getMemoryUsage(): Double? {
+        val pid = Process.myPid()
+        val statusFile = File("/proc/$pid/status")
+
+        if (!statusFile.exists() || !statusFile.canRead()) {
+            return null
+        }
+
+        try {
+            BufferedReader(FileReader(statusFile)).use { reader ->
+                while (true) {
+                    val currentLine = reader.readLine() ?: break
+                    val matcher = vmRssPattern.matcher(currentLine)
+                    if (matcher.find()) {
+                        val memoryKB = matcher.group(1)?.toDoubleOrNull()
+                        return memoryKB
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            return null
+        }
+
+        return null
+    }
+}

package/dist/cjs/config/getRNInstrumentations.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRNInstrumentations = getRNInstrumentations;
+var react_native_1 = require("react-native");
+var anr_1 = require("../instrumentations/anr");
+var appState_1 = require("../instrumentations/appState");
+var console_1 = require("../instrumentations/console");
+var crashReporting_1 = require("../instrumentations/crashReporting");
+var errors_1 = require("../instrumentations/errors");
+var frameMonitoring_1 = require("../instrumentations/frameMonitoring");
+var http_1 = require("../instrumentations/http");
+var performance_1 = require("../instrumentations/performance");
+var session_1 = require("../instrumentations/session");
+var startup_1 = require("../instrumentations/startup");
+var userActions_1 = require("../instrumentations/userActions");
+var view_1 = require("../instrumentations/view");
+var xhr_1 = require("../instrumentations/xhr");
+/** Convert Patterns (string | RegExp)[] to RegExp[] for instrumentations that require RegExp[]. */
+function toRegExpArray(patterns) {
+    return patterns.map(function (p) { return (typeof p === 'string' ? new RegExp(p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')) : p); });
+}
+/**
+ * Returns the default set of instrumentations for React Native.
+ *
+ * Reads all options from the Faro config (single source of truth).
+ * Property names are aligned with Flutter SDK FaroConfig:
+ * - cpuUsageVitals, memoryUsageVitals, anrTracking, refreshRateVitals
+ * - enableCrashReporting, enableErrorReporting
+ * - fetchVitalsInterval, ignoreUrls
+ *
+ * @example
+ * ```ts
+ * const config: ReactNativeConfig = {
+ *   app: { name: 'my-app', version: '1.0.0' },
+ *   cpuUsageVitals: true,
+ *   memoryUsageVitals: true,
+ *   anrTracking: true,
+ *   refreshRateVitals: true,
+ *   enableCrashReporting: true,
+ *   fetchVitalsInterval: 30000,
+ *   instrumentations: getRNInstrumentations(config),
+ * };
+ * ```
+ */
+function getRNInstrumentations(config) {
+    if (config === void 0) { config = {}; }
+    // Aligned with Flutter SDK FaroConfig defaults
+    var 
+    // Error & crash tracking
+    _a = config.enableErrorReporting, 
+    // Error & crash tracking
+    enableErrorReporting = _a === void 0 ? true : _a, _b = config.enableCrashReporting, enableCrashReporting = _b === void 0 ? false : _b, _c = config.anrTracking, anrTracking = _c === void 0 ? false : _c, _d = config.anrOptions, anrOptions = _d === void 0 ? {} : _d, 
+    // Performance vitals
+    _e = config.cpuUsageVitals, 
+    // Performance vitals
+    cpuUsageVitals = _e === void 0 ? true : _e, _f = config.memoryUsageVitals, memoryUsageVitals = _f === void 0 ? true : _f, _g = config.refreshRateVitals, refreshRateVitals = _g === void 0 ? false : _g, _h = config.fetchVitalsInterval, fetchVitalsInterval = _h === void 0 ? 30000 : _h, _j = config.frameMonitoringOptions, frameMonitoringOptions = _j === void 0 ? {} : _j, 
+    // Network
+    _k = config.ignoreUrls, 
+    // Network
+    ignoreUrls = _k === void 0 ? [] : _k, _l = config.enableHttpInstrumentation, enableHttpInstrumentation = _l === void 0 ? {} : _l, 
+    // Console and user actions
+    _m = config.enableConsoleCapture, 
+    // Console and user actions
+    enableConsoleCapture = _m === void 0 ? true : _m, _o = config.enableUserActions, enableUserActions = _o === void 0 ? true : _o, 
+    // Tracing
+    _p = config.enableTracing, 
+    // Tracing
+    enableTracing = _p === void 0 ? false : _p, _q = config.tracingOptions, tracingOptions = _q === void 0 ? {} : _q;
+    var instrumentations = [];
+    // Error reporting (Flutter: enableFlutterErrorReporting)
+    if (enableErrorReporting) {
+        instrumentations.push(new errors_1.ErrorsInstrumentation());
+    }
+    // Console capture - not in Flutter SDK, RN-specific
+    if (enableConsoleCapture) {
+        instrumentations.push(new console_1.ConsoleInstrumentation());
+    }
+    // Sessions - always enabled in Flutter, same here
+    instrumentations.push(new session_1.SessionInstrumentation());
+    // Views - always enabled in Flutter, same here
+    instrumentations.push(new view_1.ViewInstrumentation());
+    // App state - always enabled in Flutter, same here
+    instrumentations.push(new appState_1.AppStateInstrumentation());
+    // User actions - enabled by default, opt-out via enableUserActions
+    if (enableUserActions) {
+        instrumentations.push(new userActions_1.UserActionInstrumentation());
+    }
+    // HTTP/XHR tracking: when tracing is enabled, TracingInstrumentation patches fetch and XHR.
+    // When tracing is disabled, add HttpInstrumentation and/or XHRInstrumentation per enableHttpInstrumentation.
+    if (!enableTracing) {
+        var _r = enableHttpInstrumentation.fetch, enableFetch = _r === void 0 ? true : _r, _s = enableHttpInstrumentation.xhr, enableXhr = _s === void 0 ? true : _s;
+        var ignoredUrlsRegExp = toRegExpArray(ignoreUrls);
+        if (enableFetch) {
+            instrumentations.push(new http_1.HttpInstrumentation({ ignoredUrls: ignoredUrlsRegExp }));
+        }
+        if (enableXhr) {
+            instrumentations.push(new xhr_1.XHRInstrumentation({ ignoredUrls: ignoredUrlsRegExp }));
+        }
+    }
+    // Performance vitals (CPU/memory)
+    var perfInstrumentation = new performance_1.PerformanceInstrumentation({
+        memoryUsageVitals: memoryUsageVitals,
+        cpuUsageVitals: cpuUsageVitals,
+        fetchVitalsInterval: fetchVitalsInterval,
+    });
+    instrumentations.push(perfInstrumentation);
+    // Startup tracking - always enabled
+    instrumentations.push(new startup_1.StartupInstrumentation());
+    // Frame monitoring: enabled when refreshRateVitals is true
+    // The instrumentation reads refreshRateVitals from faro.config (single source of truth)
+    if (refreshRateVitals) {
+        instrumentations.push(new frameMonitoring_1.FrameMonitoringInstrumentation(frameMonitoringOptions));
+    }
+    // ANR detection (Android only)
+    if (anrTracking && react_native_1.Platform.OS === 'android') {
+        instrumentations.push(new anr_1.ANRInstrumentation(anrOptions));
+    }
+    // Crash reporting
+    if (enableCrashReporting) {
+        instrumentations.push(new crashReporting_1.CrashReportingInstrumentation());
+    }
+    if (enableTracing) {
+        try {
+            var TracingInstrumentation = require('@grafana/faro-react-native-tracing').TracingInstrumentation;
+            instrumentations.push(new TracingInstrumentation(tracingOptions));
+        }
+        catch (_t) {
+            console.warn('[Faro] enableTracing is true but @grafana/faro-react-native-tracing is not installed. ' +
+                'Add it to use tracing: yarn add @grafana/faro-react-native-tracing');
+        }
+    }
+    return instrumentations;
+}
+//# sourceMappingURL=getRNInstrumentations.js.map

package/dist/cjs/config/getRNInstrumentations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRNInstrumentations.js","sourceRoot":"","sources":["../../../src/config/getRNInstrumentations.ts"],"names":[],"mappings":"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","sourcesContent":["import { Platform } from 'react-native';\n\nimport type { Instrumentation, Patterns } from '@grafana/faro-core';\n\nimport { ANRInstrumentation } from '../instrumentations/anr';\nimport { AppStateInstrumentation } from '../instrumentations/appState';\nimport { ConsoleInstrumentation } from '../instrumentations/console';\nimport { CrashReportingInstrumentation } from '../instrumentations/crashReporting';\nimport { ErrorsInstrumentation } from '../instrumentations/errors';\nimport { FrameMonitoringInstrumentation } from '../instrumentations/frameMonitoring';\nimport { HttpInstrumentation } from '../instrumentations/http';\nimport { PerformanceInstrumentation } from '../instrumentations/performance';\nimport { SessionInstrumentation } from '../instrumentations/session';\nimport { StartupInstrumentation } from '../instrumentations/startup';\nimport { UserActionInstrumentation } from '../instrumentations/userActions';\nimport { ViewInstrumentation } from '../instrumentations/view';\nimport { XHRInstrumentation } from '../instrumentations/xhr';\n\nimport type { ReactNativeConfig } from './types';\n\n/** Convert Patterns (string | RegExp)[] to RegExp[] for instrumentations that require RegExp[]. */\nfunction toRegExpArray(patterns: Patterns): RegExp[] {\n  return patterns.map((p) => (typeof p === 'string' ? new RegExp(p.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')) : p));\n}\n\n/**\n * Returns the default set of instrumentations for React Native.\n *\n * Reads all options from the Faro config (single source of truth).\n * Property names are aligned with Flutter SDK FaroConfig:\n * - cpuUsageVitals, memoryUsageVitals, anrTracking, refreshRateVitals\n * - enableCrashReporting, enableErrorReporting\n * - fetchVitalsInterval, ignoreUrls\n *\n * @example\n * ```ts\n * const config: ReactNativeConfig = {\n *   app: { name: 'my-app', version: '1.0.0' },\n *   cpuUsageVitals: true,\n *   memoryUsageVitals: true,\n *   anrTracking: true,\n *   refreshRateVitals: true,\n *   enableCrashReporting: true,\n *   fetchVitalsInterval: 30000,\n *   instrumentations: getRNInstrumentations(config),\n * };\n * ```\n */\nexport function getRNInstrumentations(config: Partial<ReactNativeConfig> = {}): Instrumentation[] {\n  // Aligned with Flutter SDK FaroConfig defaults\n  const {\n    // Error & crash tracking\n    enableErrorReporting = true,\n    enableCrashReporting = false,\n    anrTracking = false,\n    anrOptions = {},\n\n    // Performance vitals\n    cpuUsageVitals = true,\n    memoryUsageVitals = true,\n    refreshRateVitals = false,\n    fetchVitalsInterval = 30000,\n    frameMonitoringOptions = {},\n\n    // Network\n    ignoreUrls = [],\n    enableHttpInstrumentation = {},\n\n    // Console and user actions\n    enableConsoleCapture = true,\n    enableUserActions = true,\n\n    // Tracing\n    enableTracing = false,\n    tracingOptions = {},\n  } = config;\n\n  const instrumentations: Instrumentation[] = [];\n\n  // Error reporting (Flutter: enableFlutterErrorReporting)\n  if (enableErrorReporting) {\n    instrumentations.push(new ErrorsInstrumentation());\n  }\n\n  // Console capture - not in Flutter SDK, RN-specific\n  if (enableConsoleCapture) {\n    instrumentations.push(new ConsoleInstrumentation());\n  }\n\n  // Sessions - always enabled in Flutter, same here\n  instrumentations.push(new SessionInstrumentation());\n\n  // Views - always enabled in Flutter, same here\n  instrumentations.push(new ViewInstrumentation());\n\n  // App state - always enabled in Flutter, same here\n  instrumentations.push(new AppStateInstrumentation());\n\n  // User actions - enabled by default, opt-out via enableUserActions\n  if (enableUserActions) {\n    instrumentations.push(new UserActionInstrumentation());\n  }\n\n  // HTTP/XHR tracking: when tracing is enabled, TracingInstrumentation patches fetch and XHR.\n  // When tracing is disabled, add HttpInstrumentation and/or XHRInstrumentation per enableHttpInstrumentation.\n  if (!enableTracing) {\n    const { fetch: enableFetch = true, xhr: enableXhr = true } = enableHttpInstrumentation;\n    const ignoredUrlsRegExp = toRegExpArray(ignoreUrls);\n    if (enableFetch) {\n      instrumentations.push(new HttpInstrumentation({ ignoredUrls: ignoredUrlsRegExp }));\n    }\n    if (enableXhr) {\n      instrumentations.push(new XHRInstrumentation({ ignoredUrls: ignoredUrlsRegExp }));\n    }\n  }\n\n  // Performance vitals (CPU/memory)\n  const perfInstrumentation = new PerformanceInstrumentation({\n    memoryUsageVitals,\n    cpuUsageVitals,\n    fetchVitalsInterval,\n  });\n  instrumentations.push(perfInstrumentation);\n\n  // Startup tracking - always enabled\n  instrumentations.push(new StartupInstrumentation());\n\n  // Frame monitoring: enabled when refreshRateVitals is true\n  // The instrumentation reads refreshRateVitals from faro.config (single source of truth)\n  if (refreshRateVitals) {\n    instrumentations.push(new FrameMonitoringInstrumentation(frameMonitoringOptions));\n  }\n\n  // ANR detection (Android only)\n  if (anrTracking && Platform.OS === 'android') {\n    instrumentations.push(new ANRInstrumentation(anrOptions));\n  }\n\n  // Crash reporting\n  if (enableCrashReporting) {\n    instrumentations.push(new CrashReportingInstrumentation());\n  }\n\n  if (enableTracing) {\n    try {\n      const { TracingInstrumentation } = require('@grafana/faro-react-native-tracing');\n      instrumentations.push(new TracingInstrumentation(tracingOptions));\n    } catch {\n      console.warn(\n        '[Faro] enableTracing is true but @grafana/faro-react-native-tracing is not installed. ' +\n          'Add it to use tracing: yarn add @grafana/faro-react-native-tracing'\n      );\n    }\n  }\n\n  return instrumentations;\n}\n"]}

package/dist/cjs/config/makeRNConfig.js

@@ -0,0 +1,115 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRNConfig = makeRNConfig;
+var faro_core_1 = require("@grafana/faro-core");
+var stackTraceParser_1 = require("../instrumentations/errors/stackTraceParser");
+var sessionConstants_1 = require("../instrumentations/session/sessionManager/sessionConstants");
+var page_1 = require("../metas/page");
+var screen_1 = require("../metas/screen");
+var sdk_1 = require("../metas/sdk");
+var console_1 = require("../transports/console");
+var fetch_1 = require("../transports/fetch");
+var offline_1 = require("../transports/offline");
+var getRNInstrumentations_1 = require("./getRNInstrumentations");
+var DEFAULT_OFFLINE_CACHE_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+/**
+ * Builds transports. FetchTransport is always added when url is provided.
+ * User can enable offline and console via enableTransports.
+ */
+function buildTransports(config) {
+    var _a;
+    var _b = config.enableTransports, enableTransports = _b === void 0 ? { offline: false, console: false } : _b;
+    if (!config.url) {
+        throw new Error('url is required. Provide the Faro collector URL.');
+    }
+    var builtTransports = [];
+    if (enableTransports.offline) {
+        builtTransports.push(new offline_1.OfflineTransport({
+            maxCacheDurationMs: DEFAULT_OFFLINE_CACHE_MS,
+        }));
+    }
+    builtTransports.push(new fetch_1.FetchTransport({
+        url: config.url,
+        apiKey: config.apiKey,
+    }));
+    if (enableTransports.console) {
+        builtTransports.push(new console_1.ConsoleTransport({ level: faro_core_1.LogLevel.DEBUG }));
+    }
+    var extraTransports = (_a = config.transports) !== null && _a !== void 0 ? _a : [];
+    return __spreadArray(__spreadArray([], builtTransports, true), extraTransports, true);
+}
+/**
+ * Builds instrumentations from config flags.
+ */
+function buildInstrumentations(config) {
+    var _a;
+    var baseInstrumentations = (0, getRNInstrumentations_1.getRNInstrumentations)(config);
+    var extraInstrumentations = (_a = config.instrumentations) !== null && _a !== void 0 ? _a : [];
+    return __spreadArray(__spreadArray([], baseInstrumentations, true), extraInstrumentations, true);
+}
+/**
+ * React Native stacktrace parser. Uses getStackFramesFromError for RN-specific formats.
+ */
+var parseStacktrace = function (err) { return ({
+    frames: (0, stackTraceParser_1.getStackFramesFromError)(err),
+}); };
+/**
+ * Creates a full Faro config from React Native flag-based config.
+ *
+ * Based on flags, builds instrumentations and transports automatically.
+ * Client just enables what they need; makeRNConfig does the rest.
+ */
+function makeRNConfig(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var defaultMetas = [(0, sdk_1.getSdkMeta)(), (0, page_1.getPageMeta)(), (0, screen_1.getScreenMeta)()];
+    var customMetas = (_a = config.metas) !== null && _a !== void 0 ? _a : [];
+    var transports = buildTransports(config);
+    var instrumentations = buildInstrumentations(config);
+    return {
+        app: config.app,
+        dedupe: (_b = config.dedupe) !== null && _b !== void 0 ? _b : true,
+        globalObjectKey: (_c = config.globalObjectKey) !== null && _c !== void 0 ? _c : faro_core_1.defaultGlobalObjectKey,
+        internalLoggerLevel: (_d = config.internalLoggerLevel) !== null && _d !== void 0 ? _d : faro_core_1.InternalLoggerLevel.ERROR,
+        isolate: (_e = config.isolate) !== null && _e !== void 0 ? _e : false,
+        parseStacktrace: (_f = config.parseStacktrace) !== null && _f !== void 0 ? _f : parseStacktrace,
+        paused: (_g = config.paused) !== null && _g !== void 0 ? _g : false,
+        preventGlobalExposure: (_h = config.preventGlobalExposure) !== null && _h !== void 0 ? _h : false,
+        unpatchedConsole: (_j = config.unpatchedConsole) !== null && _j !== void 0 ? _j : faro_core_1.defaultUnpatchedConsole,
+        batching: {
+            enabled: false,
+            sendTimeout: 250,
+            itemLimit: 50,
+        },
+        sessionTracking: __assign(__assign({}, sessionConstants_1.defaultSessionTrackingConfig), config.sessionTracking),
+        metas: __spreadArray(__spreadArray([], defaultMetas, true), customMetas, true),
+        instrumentations: instrumentations,
+        transports: transports,
+        ignoreUrls: (_k = config.ignoreUrls) !== null && _k !== void 0 ? _k : [],
+        ignoreErrors: config.ignoreErrors,
+        beforeSend: config.beforeSend,
+        preserveOriginalError: config.preserveOriginalError,
+        userActionsInstrumentation: config.userActionsOptions,
+        consoleInstrumentation: config.consoleCaptureOptions,
+    };
+}
+//# sourceMappingURL=makeRNConfig.js.map

package/dist/cjs/config/makeRNConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeRNConfig.js","sourceRoot":"","sources":["../../../src/config/makeRNConfig.ts"],"names":[],"mappings":"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","sourcesContent":["import { defaultGlobalObjectKey, defaultUnpatchedConsole, InternalLoggerLevel, LogLevel } from '@grafana/faro-core';\nimport type { Config } from '@grafana/faro-core';\n\nimport { getStackFramesFromError } from '../instrumentations/errors/stackTraceParser';\nimport { defaultSessionTrackingConfig } from '../instrumentations/session/sessionManager/sessionConstants';\nimport { getPageMeta } from '../metas/page';\nimport { getScreenMeta } from '../metas/screen';\nimport { getSdkMeta } from '../metas/sdk';\nimport { ConsoleTransport } from '../transports/console';\nimport { FetchTransport } from '../transports/fetch';\nimport { OfflineTransport } from '../transports/offline';\n\nimport { getRNInstrumentations } from './getRNInstrumentations';\nimport type { ReactNativeConfig, ReactNativeSessionTrackingConfig } from './types';\n\nconst DEFAULT_OFFLINE_CACHE_MS = 3 * 24 * 60 * 60 * 1000; // 3 days\n\n/**\n * Builds transports. FetchTransport is always added when url is provided.\n * User can enable offline and console via enableTransports.\n */\nfunction buildTransports(config: ReactNativeConfig): Config['transports'] {\n  const { enableTransports = { offline: false, console: false } } = config;\n\n  if (!config.url) {\n    throw new Error('url is required. Provide the Faro collector URL.');\n  }\n\n  const builtTransports: Config['transports'] = [];\n\n  if (enableTransports.offline) {\n    builtTransports.push(\n      new OfflineTransport({\n        maxCacheDurationMs: DEFAULT_OFFLINE_CACHE_MS,\n      })\n    );\n  }\n\n  builtTransports.push(\n    new FetchTransport({\n      url: config.url,\n      apiKey: config.apiKey,\n    })\n  );\n\n  if (enableTransports.console) {\n    builtTransports.push(new ConsoleTransport({ level: LogLevel.DEBUG }));\n  }\n\n  const extraTransports = config.transports ?? [];\n  return [...builtTransports, ...extraTransports];\n}\n\n/**\n * Builds instrumentations from config flags.\n */\nfunction buildInstrumentations(config: ReactNativeConfig): Config['instrumentations'] {\n  const baseInstrumentations = getRNInstrumentations(config);\n  const extraInstrumentations = config.instrumentations ?? [];\n  return [...baseInstrumentations, ...extraInstrumentations];\n}\n\n/**\n * React Native stacktrace parser. Uses getStackFramesFromError for RN-specific formats.\n */\nconst parseStacktrace: Config['parseStacktrace'] = (err) => ({\n  frames: getStackFramesFromError(err),\n});\n\n/**\n * Creates a full Faro config from React Native flag-based config.\n *\n * Based on flags, builds instrumentations and transports automatically.\n * Client just enables what they need; makeRNConfig does the rest.\n */\nexport function makeRNConfig(config: ReactNativeConfig): Config {\n  const defaultMetas = [getSdkMeta(), getPageMeta(), getScreenMeta()];\n  const customMetas = config.metas ?? [];\n  const transports = buildTransports(config);\n  const instrumentations = buildInstrumentations(config);\n\n  return {\n    app: config.app,\n    dedupe: config.dedupe ?? true,\n    globalObjectKey: config.globalObjectKey ?? defaultGlobalObjectKey,\n    internalLoggerLevel: config.internalLoggerLevel ?? InternalLoggerLevel.ERROR,\n    isolate: config.isolate ?? false,\n    parseStacktrace: config.parseStacktrace ?? parseStacktrace,\n    paused: config.paused ?? false,\n    preventGlobalExposure: config.preventGlobalExposure ?? false,\n    unpatchedConsole: config.unpatchedConsole ?? defaultUnpatchedConsole,\n    batching: {\n      enabled: false,\n      sendTimeout: 250,\n      itemLimit: 50,\n    },\n    sessionTracking: {\n      ...defaultSessionTrackingConfig,\n      ...config.sessionTracking,\n    } as ReactNativeSessionTrackingConfig,\n    metas: [...defaultMetas, ...customMetas],\n    instrumentations,\n    transports,\n    ignoreUrls: config.ignoreUrls ?? [],\n    ignoreErrors: config.ignoreErrors,\n    beforeSend: config.beforeSend,\n    preserveOriginalError: config.preserveOriginalError,\n    userActionsInstrumentation: config.userActionsOptions,\n    consoleInstrumentation: config.consoleCaptureOptions,\n  };\n}\n"]}

package/dist/cjs/config/sampling.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SamplingFunction = exports.SamplingRate = void 0;
+/**
+ * Fixed sampling rate.
+ *
+ * Use this when you want a constant sampling probability regardless of
+ * session context.
+ *
+ * @example
+ * ```ts
+ * sessionTracking: {
+ *   sampling: new SamplingRate(0.1), // 10% of sessions
+ * }
+ * ```
+ */
+var SamplingRate = /** @class */ (function () {
+    /**
+     * Creates a fixed sampling rate.
+     *
+     * @param rate - The fixed sampling rate (0 to 1). Values are clamped to [0, 1].
+     */
+    function SamplingRate(rate) {
+        this.rate = rate;
+    }
+    SamplingRate.prototype.resolve = function (_context) {
+        return Math.max(0, Math.min(1, this.rate));
+    };
+    return SamplingRate;
+}());
+exports.SamplingRate = SamplingRate;
+/**
+ * Dynamic sampling based on context.
+ *
+ * Use this when you want to make sampling decisions based on session
+ * metadata like user attributes, app environment, or other context.
+ *
+ * @example
+ * ```ts
+ * sessionTracking: {
+ *   sampling: new SamplingFunction((context) => {
+ *     // Sample all beta users
+ *     if (context.meta.user?.attributes?.['role'] === 'beta') {
+ *       return 1;
+ *     }
+ *     // Sample 10% of production sessions
+ *     if (context.meta.app?.environment === 'production') {
+ *       return 0.1;
+ *     }
+ *     return 1;
+ *   }),
+ * }
+ * ```
+ */
+var SamplingFunction = /** @class */ (function () {
+    /**
+     * Creates a dynamic sampler with the given function.
+     *
+     * @param fn - The function that determines the rate based on context.
+     *   Receives a {@link SamplingContext} and should return a rate between 0 and 1.
+     */
+    function SamplingFunction(fn) {
+        this.fn = fn;
+    }
+    SamplingFunction.prototype.resolve = function (context) {
+        return Math.max(0, Math.min(1, this.fn(context)));
+    };
+    return SamplingFunction;
+}());
+exports.SamplingFunction = SamplingFunction;
+//# sourceMappingURL=sampling.js.map