@truewatchtech/react-native-mobile 0.4.2 → 0.4.3

package/lib/typescript/specs/NativeFTReactNativeWebSocket.d.ts

@@ -0,0 +1,13 @@
+import type { TurboModule } from 'react-native';
+/** Internal iOS handshake reporting bridge; absent on Android and older binaries. */
+export interface Spec extends TurboModule {
+    startCapture(session: string): Promise<void>;
+    stopCapture(session: string): Promise<void>;
+    clear(): Promise<void>;
+    startResource(key: string, socketID: number, url: string, session: string, sequence: number, property: Object): Promise<void>;
+    stopResource(key: string, event: string, session: string, property: Object): Promise<void>;
+    addResource(key: string, content: Object, metrics: Object, session: string): Promise<void>;
+    releaseResource(key: string, session: string): Promise<void>;
+}
+declare const _default: Spec | null;
+export default _default;

package/lib/typescript/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.4.2";
+export declare const version = "0.4.3";

package/lib/typescript/visitorIdConfig.d.ts

@@ -0,0 +1,11 @@
+/** Anonymous Visitor ID header configuration for HTTP(S), excluding WebSockets. */
+export interface FTVisitorIdConfig {
+    header: string;
+    /** Fixed lifetime in hours; defaults to 24. Access does not renew it. */
+    ttlHours?: number;
+    /** Complete HTTP(S) prefixes constrained to the same scheme, host and port. */
+    urlPrefixes?: string[];
+    /** Native regular expressions searched against the complete URL; rules use OR. */
+    regularExpressions?: string[];
+}
+export declare function validateVisitorIdConfig(config: FTVisitorIdConfig): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@truewatchtech/react-native-mobile",
-  "version": "0.4.2",
-  "description": "Base on TrueWatchTech Android iOS React Native SDK",
+  "version": "0.4.3",
+  "description": "Base on TrueWatch Android iOS React Native SDK",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
   "types": "lib/typescript/index.d.ts",
@@ -78,7 +78,8 @@
       [
         "typescript",
         {
-          "tsc": "../../node_modules/.bin/tsc"
+          "tsc": "../../node_modules/.bin/tsc",
+          "project": "tsconfig.build.json"
         }
       ]
     ]
@@ -96,5 +97,6 @@
   },
   "directories": {
     "lib": "lib"
-  }
+  },
+  "gitHead": "61ed39427761a210cbfe6b339e71296f952f9697"
 }

package/src/ft_logger.tsx

@@ -18,8 +18,10 @@ export enum FTLogCacheDiscard {
 }
 /**
  * Configure log output configuration.
- * @param sampleRate sampling rate
+ * @param logSamplingRate Log sampling percentage in [0, 100], default 100. Supports fractional percentages and takes precedence over sampleRate.
+ * @param sampleRate Deprecated log sampling probability in [0, 1], default 1. Used only when logSamplingRate is omitted; multiplied by 100 before passing to Native.
  * @param enableLinkRumData whether to link with RUM
+ * @param enableWebViewLog Collect Browser Logs SDK events from WebViews, default false
  * @param enableCustomLog whether to enable custom logs
  * @param discardStrategy log discard strategy
  * @param logLevelFilters log level filter
@@ -27,9 +29,17 @@ export enum FTLogCacheDiscard {
  * @param logCacheLimitCount get maximum log entry count limit [1000,), default 5000
  */
 export interface FTLogConfig {
+  /**
+   * Log sampling percentage in [0, 100], default 100.
+   * Supports fractional percentages: 12.5 means 12.5%, not 0.125.
+   * Takes precedence over sampleRate when both are supplied, including 0.
+   */
+  logSamplingRate?: number;
+  /** @deprecated Use logSamplingRate. Probability in [0, 1], default 1; 0.125 maps to 12.5%. Ignored when logSamplingRate is supplied. */
   sampleRate?: number;
   enableLinkRumData?: boolean;
   enableCustomLog?: boolean;
+  enableWebViewLog?: boolean;
   discardStrategy?: FTLogCacheDiscard;
   logLevelFilters?: Array<FTLogStatus>;
   globalContext?: object;

package/src/ft_mobile_agent.tsx

@@ -3,7 +3,10 @@ import {
   NativeEventEmitter,
   NativeModules,
 } from 'react-native';
+import type { Spec as NativeFTMobileReactNativeSpec } from './specs/NativeFTMobileReactNative';
+import type { Spec as NativeFTReactNativeRUMSpec } from './specs/NativeFTReactNativeRUM';
 import { version as sdkVersion } from './version';
+import { FTRumWebSocketTracking } from './rum/FTRumWebSocketTracking';
 
 /**
  * Bridge context manager for managing shared properties across RUM and Logger modules
@@ -13,6 +16,7 @@ import { version as sdkVersion } from './version';
 class BridgeContextManager {
   private static instance: BridgeContextManager;
   private properties: Map<string, any> = new Map();
+  private longTaskContextEnabled = false;
 
   private constructor() {
     // Initialize with SDK version information
@@ -55,11 +59,35 @@ class BridgeContextManager {
       Object.entries(properties).forEach(([key, value]) => {
         this.properties.set(key, value);
       });
+      if (this.longTaskContextEnabled) {
+        this.syncLongTaskContext();
+      }
     } catch (error) {
       console.warn('Failed to append bridge context:', error);
     }
   }
 
+  public configureLongTaskContext(enabled: boolean): void {
+    this.longTaskContextEnabled = enabled;
+    if (enabled) {
+      this.syncLongTaskContext();
+    }
+  }
+
+  private syncLongTaskContext(): void {
+    try {
+      // Apply the snapshot before JS can block. An async native call may run after
+      // the frame that detects the long task and attach stale context to it.
+      const rum: NativeFTReactNativeRUMSpec =
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        require('./specs/NativeFTReactNativeRUM').default;
+      rum.setLongTaskContext(this.mergeWithLocalPropertiesSync());
+    } catch (error) {
+      // Context synchronization must not make a destroyed/older bridge crash the host.
+      console.warn('Failed to sync JS long task bridge context:', error);
+    }
+  }
+
   /**
    * Merge bridge context properties with local properties
    * Bridge context properties take precedence over local properties
@@ -135,6 +163,8 @@ export type FTRemoteConfigOverrideMatch = {
 /**
  * Values that can be modified by remote config override rules.
  * These values will adjust the fetched remote configuration before it is applied.
+ * Omitted fields are not changed by this rule. Sampling percentages use [0, 100]
+ * and support fractions (12.5 means 12.5%); legacy probabilities use [0, 1].
  */
 export type FTRemoteConfigOverrideValues = {
   env?: string;
@@ -143,7 +173,21 @@ export type FTRemoteConfigOverrideValues = {
   compressIntakeRequests?: boolean;
   syncPageSize?: number;
   syncSleepTime?: number;
+  /** RUM session sampling percentage override in [0, 100]; takes precedence over rumSampleRate, including 0. */
+  sessionSamplingRate?: number;
+  /** Error session sampling percentage override in [0, 100]; takes precedence over rumSessionOnErrorSampleRate, including 0. */
+  sessionOnErrorSamplingRate?: number;
+  /** Trace sampling percentage override in [0, 100]; takes precedence over traceSampleRate, including 0. */
+  traceSamplingRate?: number;
+  /** Log sampling percentage override in [0, 100]; takes precedence over logSampleRate, including 0. */
+  logSamplingRate?: number;
+  /** Session Replay sampling percentage override in [0, 100]; fractional percentages are supported. */
+  sessionReplaySamplingRate?: number;
+  /** Error replay sampling percentage override in [0, 100]; fractional percentages are supported. */
+  sessionReplayOnErrorSamplingRate?: number;
+  /** @deprecated Use sessionSamplingRate. Legacy RUM probability override in [0, 1]; 0.125 maps to 12.5%. */
   rumSampleRate?: number;
+  /** @deprecated Use sessionOnErrorSamplingRate. Legacy error session probability override in [0, 1]. */
   rumSessionOnErrorSampleRate?: number;
   rumEnableTraceUserAction?: boolean;
   rumEnableTraceUserView?: boolean;
@@ -155,12 +199,15 @@ export type FTRemoteConfigOverrideValues = {
   rumEnableTrackAppANR?: boolean;
   rumEnableTraceWebView?: boolean;
   rumAllowWebViewHost?: Array<string>;
+  /** @deprecated Use traceSamplingRate. Legacy Trace probability override in [0, 1]. */
   traceSampleRate?: number;
   traceEnableAutoTrace?: boolean;
   traceType?: string;
+  /** @deprecated Use logSamplingRate. Legacy log probability override in [0, 1]. */
   logSampleRate?: number;
   logLevelFilters?: Array<string>;
   logEnableCustomLog?: boolean;
+  logEnableWebViewLog?: boolean;
   logEnableConsoleLog?: boolean;
 };
 
@@ -241,6 +288,10 @@ export interface FTMobileConfig {
   compressIntakeRequests?: boolean;
   enableDataFilter?: boolean;
   dataFilters?: Record<string, Array<string>>;
+  /** Shared WebView host allowlist for RUM and Log. Omitted uses the legacy RUM
+   * config; null allows every host; [] disables bridge access. Remote config wins.
+   */
+  allowWebViewHost?: Array<string> | null;
   globalContext?: object;
   groupIdentifiers?: Array<string>;
   enableLimitWithDbSize?: boolean;
@@ -292,6 +343,8 @@ type FTMobileReactNativeType = {
    * @returns a Promise.
    */
   unbindRUMUserData(): Promise<void>;
+  /** Rotate the native anonymous Visitor ID for subsequent requests. */
+  resetVisitorId(): Promise<void>;
   /**
    * Add custom global parameters. Applies to RUM and Log data
    * @param context custom global parameters.
@@ -361,8 +414,10 @@ type FTMobileReactNativeType = {
 
 class FTMobileReactNativeWrapper implements FTMobileReactNativeType {
   /* eslint-disable @typescript-eslint/no-var-requires */
-  private sdk: FTMobileReactNativeType =
+  private sdk: NativeFTMobileReactNativeSpec =
     require('./specs/NativeFTMobileReactNative').default;
+  private rum: NativeFTReactNativeRUMSpec =
+    require('./specs/NativeFTReactNativeRUM').default;
   /* eslint-enable @typescript-eslint/no-var-requires */
 
   private emitter: NativeEventEmitter | null = null;
@@ -385,7 +440,12 @@ class FTMobileReactNativeWrapper implements FTMobileReactNativeType {
     ) {
       config.datakitUrl = config.serverUrl;
     }
-    return this.sdk.sdkConfig(config);
+    const nativeConfig = { ...config };
+    // Keep undefined equivalent to omission; explicit null overrides legacy hosts.
+    if (nativeConfig.allowWebViewHost === undefined) {
+      delete nativeConfig.allowWebViewHost;
+    }
+    return this.sdk.sdkConfig(nativeConfig);
   }
   setDatakitURL(datakitUrl: string): Promise<void> {
     return this.sdk.setDatakitURL(datakitUrl);
@@ -401,6 +461,9 @@ class FTMobileReactNativeWrapper implements FTMobileReactNativeType {
   ): Promise<void> {
     return this.sdk.bindRUMUserData(userId, userName, userEmail, extra);
   }
+  resetVisitorId(): Promise<void> {
+    return this.sdk.resetVisitorId();
+  }
   unbindRUMUserData(): Promise<void> {
     return this.sdk.unbindRUMUserData();
   }
@@ -419,24 +482,33 @@ class FTMobileReactNativeWrapper implements FTMobileReactNativeType {
   flushSyncData(): Promise<void> {
     return this.sdk.flushSyncData();
   }
-  shutDown(): Promise<void> {
-    return this.sdk.shutDown();
+  async shutDown(): Promise<void> {
+    bridgeContextManager.configureLongTaskContext(false);
+    try {
+      FTRumWebSocketTracking.shutDown();
+      await this.rum.stopLongTaskTracking();
+    } finally {
+      await this.sdk.shutDown();
+    }
   }
   clearAllData(): Promise<void> {
     return this.sdk.clearAllData();
   }
   appendBridgeContext(properties: Record<string, any>): void {
-    // Use bridgeContextManager to store properties in JavaScript and send to native SDK
+    // Store properties in JS and update the native long task snapshot when enabled.
     bridgeContextManager.appendBridgeContext(properties);
   }
   updateRemoteConfig(): Promise<FTRemoteConfigResult> {
-    return this.sdk.updateRemoteConfig();
+    return this.sdk.updateRemoteConfig() as Promise<FTRemoteConfigResult>;
   }
   updateRemoteConfigWithMiniUpdateInterval(
     interval: number,
     rules?: Array<FTRemoteConfigOverrideRule>
   ): Promise<FTRemoteConfigResult> {
-    return this.sdk.updateRemoteConfigWithMiniUpdateInterval(interval, rules);
+    return this.sdk.updateRemoteConfigWithMiniUpdateInterval(
+      interval,
+      rules
+    ) as Promise<FTRemoteConfigResult>;
   }
   addRemoteConfigListener(
     listener: (result: FTRemoteConfigResult) => void

package/src/ft_rum.tsx

@@ -1,7 +1,12 @@
+import { FTVisitorIdConfig, validateVisitorIdConfig } from './visitorIdConfig';
 // import { NativeModules } from 'react-native';
+import { Platform } from 'react-native';
 import { FTRumErrorTracking } from './rum/FTRumErrorTracking';
 import { FTRumActionTracking } from './rum/FTRumActionTracking';
+import { FTBabelInteractionTracking } from './rum/FTBabelInteractionTracking';
+import { FTRumWebSocketTracking } from './rum/FTRumWebSocketTracking';
 import { bridgeContextManager } from './ft_mobile_agent';
+import { normalizeLongTaskThreshold } from './rum/longTasksUtils';
 
 /**
  * Error monitoring type.
@@ -72,17 +77,25 @@ export enum IOSCrashMonitoringType {
  * Set RUM tracking conditions.
  * @param androidAppId appId, apply during monitoring
  * @param iOSAppId appId, apply during monitoring
- * @param sampleRate sampling rate
- * @param sessionOnErrorSampleRate error session sampling rate. For sessions not sampled, if ERROR is hit, collect data 1 minute before the error occurs
+ * @param sessionSamplingRate RUM session sampling percentage in [0, 100], default 100. Supports fractional percentages and takes precedence over sampleRate.
+ * @param sessionOnErrorSamplingRate Sampling percentage in [0, 100] for otherwise unsampled sessions when an error occurs, default 0. Supports fractional percentages and takes precedence over sessionOnErrorSampleRate.
+ * @param sampleRate Deprecated RUM session sampling probability in [0, 1], default 1. Used only when sessionSamplingRate is omitted; multiplied by 100 before passing to Native.
+ * @param sessionOnErrorSampleRate Deprecated error session sampling probability in [0, 1], default 0. Used only when sessionOnErrorSamplingRate is omitted; multiplied by 100 before passing to Native.
  * @param enableAutoTrackUserAction whether to automatically collect react-native control click events, can set actionName with accessibilityLabel when enabled
  * @param enableTrackError whether to automatically collect react-native Error
  * @param enableTrackNativeCrash whether to collect Native Error
  * @param enableTrackNativeAppANR whether to collect Native ANR
  * @param enableTrackNativeFreeze whether to collect Native Freeze
  * @param nativeFreezeDurationMs set the threshold for collecting Native Freeze, value range [100,), unit ms. iOS default 250ms, Android default 1000ms
+ * @param enableLongTask whether to collect React Native JavaScript LongTasks, default false
+ * @param longTaskThresholdMs set the threshold for collecting React Native JavaScript LongTasks, unit ms. Defaults to 100 and is clamped to [100, 5000]
  * @param enableNativeUserAction whether to start Native Action tracking, Button click events, recommended to disable for pure react-native apps
  * @param enableNativeUserView whether to start Native View auto tracking, recommended to disable for pure react-native apps
  * @param enableNativeUserResource whether to automatically collect react-native Resource
+ * @param enableIOSWebSocketResource whether to collect iOS WebSocket opening handshakes as RUM Resources. Defaults to false.
+ * Independent of enableNativeUserResource. Android native WebSocket collection is unaffected.
+ * iOS WebSocket Trace header injection requires both this option and enableNativeAutoTrace.
+ * When disabled, new iOS WebSocket connections are not instrumented or automatically injected with Trace headers by this SDK.
  * @param enableResourceHostIP whether to collect network request Host IP (only for native http, iOS 13 and above)
  * @param errorMonitorType error monitoring supplement type
  * @param deviceMonitorType page monitoring supplement type
@@ -91,13 +104,30 @@ export enum IOSCrashMonitoringType {
  * @param rumCacheLimitCount RUM max cache size, default 100_000
  * @param rumDiscardStrategy RUM data discard strategy
  * @param enableTraceWebView Set whether to enable WebView data collection, default true
- * @param allowWebViewHost Set specific hosts or domains allowed to collect WebView data, nil means collect all
+ * @param allowWebViewHost Deprecated; use FTMobileConfig.allowWebViewHost for shared WebView host filtering.
  * @param iosCrashMonitoringType iOS crash monitoring type , default is highCompatibility, which does not include Mach exceptions for better compatibility. you must enable system crash monitoring to get crash stack traces and crash information.
  */
 export interface FTRUMConfig {
+  /** Valid config enables Visitor ID; omitted/null disables it. */
+  visitorIdConfig?: FTVisitorIdConfig | null;
   androidAppId: string;
   iOSAppId: string;
+  /**
+   * RUM session sampling percentage in [0, 100], default 100.
+   * Supports fractional percentages: 12.5 means 12.5%, not 0.125.
+   * Takes precedence over sampleRate when both are supplied, including 0.
+   * Setting 0 disables regular session sampling; error session sampling is separate.
+   */
+  sessionSamplingRate?: number;
+  /** @deprecated Use sessionSamplingRate. Probability in [0, 1], default 1; 0.125 maps to 12.5%. Ignored when sessionSamplingRate is supplied. */
   sampleRate?: number;
+  /**
+   * Sampling percentage for otherwise unsampled RUM sessions when an error occurs.
+   * Range [0, 100], default 0; fractional percentages are supported.
+   * Takes precedence over sessionOnErrorSampleRate when both are supplied, including 0.
+   */
+  sessionOnErrorSamplingRate?: number;
+  /** @deprecated Use sessionOnErrorSamplingRate. Probability in [0, 1], default 0; multiplied by 100. Ignored when sessionOnErrorSamplingRate is supplied. */
   sessionOnErrorSampleRate?: number;
   enableAutoTrackUserAction?: boolean;
   enableAutoTrackError?: boolean;
@@ -105,9 +135,12 @@ export interface FTRUMConfig {
   enableTrackNativeAppANR?: boolean;
   enableTrackNativeFreeze?: boolean;
   nativeFreezeDurationMs?: number;
+  enableLongTask?: boolean;
+  longTaskThresholdMs?: number;
   enableNativeUserAction?: boolean;
   enableNativeUserView?: boolean;
   enableNativeUserResource?: boolean;
+  enableIOSWebSocketResource?: boolean;
   enableResourceHostIP?: boolean;
   errorMonitorType?: ErrorMonitorType;
   deviceMonitorType?: DeviceMetricsMonitorType;
@@ -116,7 +149,8 @@ export interface FTRUMConfig {
   rumCacheLimitCount?: number;
   rumDiscardStrategy?: FTRUMCacheDiscard;
   enableTraceWebView?: boolean;
-  allowWebViewHost?: Array<string>;
+  /** @deprecated Configure the shared host allowlist in FTMobileConfig.allowWebViewHost. */
+  allowWebViewHost?: Array<string> | null;
   iosCrashMonitoringType?: IOSCrashMonitoringType;
 }
 /**
@@ -192,10 +226,17 @@ type FTReactNativeRUMType = {
   /**
    * view load duration.
    * @param viewName view name
-   * @param loadTime view load duration
+   * @param loadTime monotonic view load duration in nanoseconds
    * @returns a Promise.
    */
   onCreateView(viewName: string, loadTime: number): Promise<void>;
+  /**
+   * Replace the current active View's loading duration, between startView and stopView.
+   * @param duration monotonic elapsed time in nanoseconds; a non-negative safe integer.
+   * Zero clears loading time. Late calls can update a newer View; no View ID is supplied.
+   * @returns a Promise for the native call, not for data upload.
+   */
+  updateViewLoadingTime(duration: number): Promise<void>;
   /**
    * view start.
    * @param viewName page name
@@ -259,20 +300,73 @@ type FTReactNativeRUMType = {
   ): Promise<void>;
 };
 
+function isBabelPluginEnabled(): boolean {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis.__FT_RN_BABEL_PLUGIN_ENABLED__ === true;
+  }
+  if (typeof global !== 'undefined') {
+    return global.__FT_RN_BABEL_PLUGIN_ENABLED__ === true;
+  }
+  return false;
+}
+
 class FTReactNativeRUMWrapper implements FTReactNativeRUMType {
+  private webSocketConfigVersion = 0;
   // eslint-disable-next-line @typescript-eslint/no-var-requires
   private rum: FTReactNativeRUMType = require('./specs/NativeFTReactNativeRUM')
     .default;
 
   setConfig(config: FTRUMConfig): Promise<void> {
+    if (config.visitorIdConfig != null) {
+      try {
+        validateVisitorIdConfig(config.visitorIdConfig);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    }
+    bridgeContextManager.configureLongTaskContext(
+      config.enableLongTask === true
+    );
+    const webSocketLifecycle = FTRumWebSocketTracking.getLifecycleVersion();
+    const webSocketConfigVersion = ++this.webSocketConfigVersion;
+    const trackWebSocket = config.enableIOSWebSocketResource === true;
     console.log('FTRUMConfig');
     if (config.enableAutoTrackError) {
       FTRumErrorTracking.startTracking();
     }
-    if (config.enableAutoTrackUserAction) {
+    const babelPluginEnabled = isBabelPluginEnabled();
+    FTBabelInteractionTracking.configure({
+      trackInteractions:
+        babelPluginEnabled && Boolean(config.enableAutoTrackUserAction),
+      actionReporter: (actionName, actionType, property) =>
+        this.startAction(actionName, actionType, property),
+    });
+    if (config.enableAutoTrackUserAction && !babelPluginEnabled) {
       FTRumActionTracking.startTracking();
+    } else {
+      FTRumActionTracking.stopTracking();
     }
-    return this.rum.setConfig(config);
+    return this.rum
+      .setConfig({
+        ...config,
+        enableLongTask: config.enableLongTask === true,
+        longTaskThresholdMs: normalizeLongTaskThreshold(
+          config.longTaskThresholdMs
+        ),
+      })
+      .then(() => {
+        if (
+          webSocketLifecycle !== FTRumWebSocketTracking.getLifecycleVersion() ||
+          webSocketConfigVersion !== this.webSocketConfigVersion
+        ) {
+          return;
+        }
+        if (Platform.OS === 'ios' && trackWebSocket) {
+          FTRumWebSocketTracking.startTracking(this);
+        } else {
+          FTRumWebSocketTracking.stopTracking();
+        }
+      });
   }
   startAction(
     actionName: string,
@@ -297,6 +391,16 @@ class FTReactNativeRUMWrapper implements FTReactNativeRUMType {
   onCreateView(viewName: string, loadTime: number): Promise<void> {
     return this.rum.onCreateView(viewName, loadTime);
   }
+  updateViewLoadingTime(duration: number): Promise<void> {
+    if (!Number.isSafeInteger(duration) || duration < 0) {
+      return Promise.reject(
+        new RangeError(
+          'duration must be a non-negative safe integer in nanoseconds'
+        )
+      );
+    }
+    return this.rum.updateViewLoadingTime(duration);
+  }
   startView(viewName: string, property?: object): Promise<void> {
     // Automatically merge bridge context properties with local properties
     const mergedProperties =

package/src/ft_tracing.tsx

@@ -1,6 +1,8 @@
 // import { NativeModules } from 'react-native';
 //FTReactNativeTrace
 
+import { FTRumWebSocketTracking } from './rum/FTRumWebSocketTracking';
+
 /**
  * Trace types for use.
  */
@@ -33,12 +35,20 @@ export enum TraceType {
 }
 /**
  * Configure trace.
- * @param sampleRate sampling rate
+ * @param traceSamplingRate Trace sampling percentage in [0, 100], default 100. Supports fractional percentages and takes precedence over sampleRate.
+ * @param sampleRate Deprecated Trace sampling probability in [0, 1], default 1. Used only when traceSamplingRate is omitted; multiplied by 100 before passing to Native.
  * @param traceType trace type
  * @param enableLinkRUMData whether to link with RUM data
  * @param enableNativeAutoTrace whether to enable automatic tracing
  */
 export interface FTTraceConfig {
+  /**
+   * Trace sampling percentage in [0, 100], default 100.
+   * Supports fractional percentages: 12.5 means 12.5%, not 0.125.
+   * Takes precedence over sampleRate when both are supplied, including 0.
+   */
+  traceSamplingRate?: number;
+  /** @deprecated Use traceSamplingRate. Probability in [0, 1], default 1; 0.125 maps to 12.5%. Ignored when traceSamplingRate is supplied. */
   sampleRate?: number;
   traceType?: TraceType;
   enableLinkRUMData?: boolean;
@@ -68,13 +78,25 @@ type FTReactNativeTraceType = {
 };
 
 class FTReactNativeTraceWrapper implements FTReactNativeTraceType {
+  private webSocketConfigVersion = 0;
   /* eslint-disable @typescript-eslint/no-var-requires */
   private trace: FTReactNativeTraceType =
     require('./specs/NativeFTReactNativeTrace').default;
   /* eslint-enable @typescript-eslint/no-var-requires */
 
   setConfig(config: FTTraceConfig): Promise<void> {
-    return this.trace.setConfig(config);
+    const webSocketLifecycle = FTRumWebSocketTracking.getLifecycleVersion();
+    const webSocketConfigVersion = ++this.webSocketConfigVersion;
+    const traceWebSocket = config.enableNativeAutoTrace === true;
+    return this.trace.setConfig(config).then(() => {
+      if (
+        webSocketLifecycle !== FTRumWebSocketTracking.getLifecycleVersion() ||
+        webSocketConfigVersion !== this.webSocketConfigVersion
+      ) {
+        return;
+      }
+      FTRumWebSocketTracking.setNativeAutoTraceEnabled(traceWebSocket);
+    });
   }
   /**
    * Get trace HTTP request header data.

package/src/index.tsx

@@ -28,6 +28,8 @@ import {
 import { FTTraceConfig, FTReactNativeTrace, TraceType } from './ft_tracing';
 import { FTRumActionTracking } from './rum/FTRumActionTracking';
 import { FTRumErrorTracking } from './rum/FTRumErrorTracking';
+import { FTBabelInteractionTracking } from './rum/FTBabelInteractionTracking';
+import { __ftExtractText } from './rum/FTBabelUtils';
 
 export {
   FTMobileReactNative,
@@ -56,4 +58,10 @@ export {
   TraceType,
   FTRumActionTracking,
   FTRumErrorTracking,
+  FTBabelInteractionTracking,
+  __ftExtractText,
 };
+
+export type { FTVisitorIdConfig } from './visitorIdConfig';
+
+export { FTRumViewTracking } from './rum/FTRumViewTracking';