@truewatchtech/react-native-mobile 0.4.3-alpha.2 → 0.4.3

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

@@ -33,6 +33,7 @@ export interface Spec extends TurboModule {
      * @returns a Promise.
      */
     unbindRUMUserData(): Promise<void>;
+    resetVisitorId(): Promise<void>;
     /**
      * Add custom global parameters. Applies to RUM and Log data
      * @param context custom global parameters.

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

@@ -32,10 +32,16 @@ export interface Spec extends TurboModule {
     /**
      * 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 View's loading duration; non-negative safe integer nanoseconds. */
+    updateViewLoadingTime(duration: number): Promise<void>;
+    /** Framework integration: duration in ns; epoch start in ms, converted natively. */
+    onCreateViewWithLoadStart(viewName: string, loadTime: number, loadStartEpochMs: number): Promise<void>;
+    /** Framework integration: Manual = 0, Automatic = 1. */
+    startViewWithTrackingType(viewName: string, property: Object | undefined, trackingType: number): Promise<void>;
     /**
      * view start.
      * @param viewName page name

package/lib/typescript/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.4.3-alpha.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,6 +1,6 @@
 {
   "name": "@truewatchtech/react-native-mobile",
-  "version": "0.4.3-alpha.2",
+  "version": "0.4.3",
   "description": "Base on TrueWatch Android iOS React Native SDK",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -78,7 +78,8 @@
       [
         "typescript",
         {
-          "tsc": "../../node_modules/.bin/tsc"
+          "tsc": "../../node_modules/.bin/tsc",
+          "project": "tsconfig.build.json"
         }
       ]
     ]
@@ -97,5 +98,5 @@
   "directories": {
     "lib": "lib"
   },
-  "gitHead": "b7f95ab574f7e8c0e13c91d14eea9cba0fad7531"
+  "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

@@ -163,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;
@@ -171,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;
@@ -183,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;
 };
 
@@ -269,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;
@@ -320,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.
@@ -415,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);
@@ -431,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();
   }

package/src/ft_rum.tsx

@@ -1,3 +1,4 @@
+import { FTVisitorIdConfig, validateVisitorIdConfig } from './visitorIdConfig';
 // import { NativeModules } from 'react-native';
 import { Platform } from 'react-native';
 import { FTRumErrorTracking } from './rum/FTRumErrorTracking';
@@ -76,8 +77,10 @@ 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
@@ -101,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;
@@ -129,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;
 }
 /**
@@ -205,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
@@ -289,6 +317,13 @@ class FTReactNativeRUMWrapper implements FTReactNativeRUMType {
     .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
     );
@@ -356,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

@@ -35,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;

package/src/index.tsx

@@ -61,3 +61,7 @@ export {
   FTBabelInteractionTracking,
   __ftExtractText,
 };
+
+export type { FTVisitorIdConfig } from './visitorIdConfig';
+
+export { FTRumViewTracking } from './rum/FTRumViewTracking';

package/src/rum/FTRumViewTracking.ts

@@ -0,0 +1,179 @@
+import { AppState } from 'react-native';
+import type { AppStateStatus } from 'react-native';
+import { FTReactNativeRUM } from '../ft_rum';
+import { bridgeContextManager } from '../ft_mobile_agent';
+import type { Spec as NativeRUMSpec } from '../specs/NativeFTReactNativeRUM';
+
+type Route = { key: string; name: string };
+type Loading = { monotonicMs: number; epochMs: number };
+const MAX_PENDING_LOAD_MS = 15 * 60 * 1000;
+
+/** Shared lifecycle coordinator for navigation adapters. Use one per navigator. */
+export class FTRumViewTracking {
+  private current?: Route;
+  private active?: { key: string; generation: number };
+  private generation = 0;
+  private lifecycle = 0;
+  private state: AppStateStatus | null = null;
+  private subscription?: { remove(): void };
+  private loading = new Map<string, Loading>();
+
+  constructor(private readonly onBackground?: () => void) {}
+
+  start(): void {
+    if (this.subscription) return;
+    this.state = AppState.currentState;
+    const lifecycle = ++this.lifecycle;
+    const listener = (state: AppStateStatus): void => {
+      if (lifecycle === this.lifecycle) this.onAppState(state);
+    };
+    const subscription = AppState.addEventListener('change', listener);
+    // RN < 0.65 uses removeEventListener instead of returning a subscription.
+    const legacyAppState = AppState as typeof AppState & {
+      removeEventListener?: (type: string, callback: typeof listener) => void;
+    };
+    this.subscription = subscription || {
+      remove: () => legacyAppState.removeEventListener?.('change', listener),
+    };
+  }
+
+  /** Capture both clocks at the loading boundary, before any async work. */
+  beginLoad(key: string): void {
+    this.start();
+    this.pruneLoading();
+    if (this.state === 'background' || this.loading.has(key)) return;
+    if (
+      typeof performance === 'undefined' ||
+      typeof performance.now !== 'function'
+    )
+      return;
+    // Only the latest transition can supply loading for this navigator.
+    this.loading.clear();
+    this.loading.set(key, {
+      monotonicMs: performance.now(),
+      epochMs: Date.now(),
+    });
+  }
+
+  /** Remember a transitioning route so foreground recovery uses the current page. */
+  setCurrent(route: Route): void {
+    this.start();
+    this.current = { key: route.key, name: route.name };
+  }
+
+  show(route: Route, loadingKey: string = route.key): number | undefined {
+    this.setCurrent(route);
+    this.pruneLoading();
+    const loading = this.loading.get(loadingKey);
+    this.loading.clear();
+    if (this.state !== 'active') return undefined;
+    if (this.active?.key === route.key) return this.active.generation;
+    this.active = { key: route.key, generation: ++this.generation };
+    if (loading) {
+      const durationNs = Math.floor(
+        (performance.now() - loading.monotonicMs) * 1000000
+      );
+      if (Number.isFinite(durationNs) && durationNs > 0) {
+        this.report(
+          this.nativeRUM.onCreateViewWithLoadStart(
+            route.name,
+            durationNs,
+            Number.isFinite(loading.epochMs) ? loading.epochMs : 0
+          )
+        );
+      }
+    }
+    // Enqueue these calls together. Waiting for a Promise here could start a stale
+    // page after background/route changes; native consumes loading before start.
+    this.report(
+      this.nativeRUM.startViewWithTrackingType(
+        route.name,
+        bridgeContextManager.mergeWithLocalPropertiesSync(),
+        1 // Automatic is an internal framework bridge detail.
+      )
+    );
+    return this.active.generation;
+  }
+
+  /** Apply a completed interval only to the appearance that started it. */
+  updateLoadingTime(
+    key: string,
+    generation: number | undefined,
+    durationNs: number
+  ): void {
+    if (
+      this.state !== 'active' ||
+      !this.active ||
+      this.active.key !== key ||
+      this.active.generation !== generation ||
+      !Number.isSafeInteger(durationNs) ||
+      durationNs <= 0
+    )
+      return;
+    // Enqueue immediately; never let a Promise continuation update another View.
+    this.report(FTReactNativeRUM.updateViewLoadingTime(durationNs));
+  }
+
+  /** Only the appearance that owns the active generation may close it. */
+  hide(key: string, generation: number | undefined): void {
+    if (this.state !== 'active') return;
+    if (
+      !this.active ||
+      this.active.key !== key ||
+      this.active.generation !== generation
+    )
+      return;
+    this.active = undefined;
+    this.current = undefined;
+    this.report(FTReactNativeRUM.stopView());
+  }
+
+  stop(): void {
+    ++this.lifecycle;
+    this.subscription?.remove();
+    this.subscription = undefined;
+    if (this.active && this.state === 'active')
+      this.report(FTReactNativeRUM.stopView());
+    this.active = undefined;
+    this.current = undefined;
+    this.loading.clear();
+    // Never reuse generation values: callbacks from a previous subscription can arrive late.
+  }
+
+  private onAppState = (state: AppStateStatus): void => {
+    if (state === this.state) return;
+    this.state = state;
+    if (state === 'background') {
+      // Native closes Automatic Views at its own history boundary. No JS stop.
+      this.active = undefined;
+      this.loading.clear();
+      this.onBackground?.();
+    } else if (state === 'active' && this.current) {
+      this.show(this.current);
+    }
+  };
+
+  private pruneLoading(): void {
+    const now =
+      typeof performance !== 'undefined' &&
+      typeof performance.now === 'function'
+        ? performance.now()
+        : NaN;
+    for (const [key, load] of this.loading) {
+      const age = now - load.monotonicMs;
+      if (!Number.isFinite(age) || age < 0 || age >= MAX_PENDING_LOAD_MS)
+        this.loading.delete(key);
+    }
+  }
+
+  private get nativeRUM(): NativeRUMSpec {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('../specs/NativeFTReactNativeRUM').default;
+  }
+
+  private report(result: Promise<void>): void {
+    result.catch((error) =>
+      console.warn('[TrueWatch] Automatic View tracking failed', error)
+    );
+  }
+}

package/src/rum/FTRumWebSocketNative.ts

@@ -1,5 +1,6 @@
 import NativeWebSocket from '../specs/NativeFTReactNativeWebSocket';
 import { bridgeContextManager } from '../ft_mobile_agent';
+import type { WebSocketTimingMetrics } from './FTRumWebSocketTiming';
 
 export interface NativeWebSocketResource {
   url: string;
@@ -51,7 +52,7 @@ export class NativeWebSocketSession {
   addResource(
     key: string,
     content: NativeWebSocketResource,
-    metrics: { duration?: number }
+    metrics: Partial<WebSocketTimingMetrics>
   ): Promise<void> {
     return NativeWebSocket!.addResource(key, content, metrics, this.session);
   }

package/src/rum/FTRumWebSocketTiming.ts

@@ -1,5 +1,14 @@
+export interface WebSocketTimingMetrics {
+  duration: number;
+  // Decimal int64 nanoseconds: epoch nanoseconds exceed JS number precision.
+  fetchStartNsTimeInterval?: string;
+  fetchEndNsTimeInterval?: string;
+}
+
 /** Measures only the JS-observed opening handshake; bridge delays are excluded. */
-export function startWebSocketTiming(): () => number | undefined {
+export function startWebSocketTiming(): () =>
+  | WebSocketTimingMetrics
+  | undefined {
   const wallStart = readWallTime();
   let monotonicNow: (() => number) | undefined;
   let monotonicStart: number | undefined;
@@ -36,10 +45,33 @@ export function startWebSocketTiming(): () => number | undefined {
     }
     // Resource metrics use nanoseconds. Do not send an invalid bridge number.
     const durationNs = Math.round(durationMs * 1e6);
-    return Number.isSafeInteger(durationNs) ? durationNs : undefined;
+    if (!Number.isSafeInteger(durationNs)) return undefined;
+    const metrics: WebSocketTimingMetrics = { duration: durationNs };
+    if (
+      wallStart !== undefined &&
+      Number.isSafeInteger(wallStart) &&
+      wallStart > 0
+    ) {
+      // Add the monotonic elapsed interval to the start epoch, not Date.now()
+      // at completion. Split milliseconds/remainder to avoid epoch-ns doubles.
+      const endMs = wallStart + Math.floor(durationNs / 1e6);
+      const start = `${wallStart}000000`;
+      const end = `${endMs}${String(durationNs % 1e6).padStart(6, '0')}`;
+      if (Number.isSafeInteger(endMs) && fitsInt64(start) && fitsInt64(end)) {
+        metrics.fetchStartNsTimeInterval = start;
+        metrics.fetchEndNsTimeInterval = end;
+      }
+    }
+    return metrics;
   };
 }
 
+function fitsInt64(value: string): boolean {
+  return (
+    value.length < 19 || (value.length === 19 && value <= '9223372036854775807')
+  );
+}
+
 function readWallTime(): number | undefined {
   try {
     const time = Date.now();

package/src/rum/FTRumWebSocketTracking.ts

@@ -2,6 +2,7 @@
 import { Platform } from 'react-native';
 import NativeFTReactNativeTrace from '../specs/NativeFTReactNativeTrace';
 import { startWebSocketTiming } from './FTRumWebSocketTiming';
+import type { WebSocketTimingMetrics } from './FTRumWebSocketTiming';
 import {
   clearNativeWebSocketSessions,
   startNativeWebSocketSession,
@@ -42,7 +43,7 @@ interface FTRumWebSocketResourceReporter {
   addResource(
     key: string,
     resource: FTRUMWebSocketResource,
-    metrics?: { duration?: number; resource_http_protocol?: string }
+    metrics?: WebSocketTimingMetrics
   ): Promise<void>;
 }
 
@@ -330,7 +331,7 @@ export class FTRumWebSocketTracking {
         return;
       }
       completed = true;
-      const duration = stopTiming();
+      const timing = stopTiming();
       // Freeze the observed boundary before inspecting or parsing error data.
       const error = getError?.();
       if (
@@ -368,7 +369,7 @@ export class FTRumWebSocketTracking {
             requestHeader: requestHeaders,
             webSocketEvent: event,
           },
-          duration,
+          timing,
           error,
           errorReady
         );
@@ -383,7 +384,7 @@ export class FTRumWebSocketTracking {
         requestHeaders,
         resourceStatus,
         state,
-        duration,
+        timing,
         error,
         errorReady
       );
@@ -620,7 +621,7 @@ export class FTRumWebSocketTracking {
     requestHeader: Record<string, unknown>,
     resourceStatus: number,
     webSocketHandshakeState: WebSocketHandshakeState,
-    duration: number | undefined,
+    timing: WebSocketTimingMetrics | undefined,
     error?: WebSocketHandshakeError,
     errorReady?: Promise<void>
   ): Promise<void> {
@@ -657,14 +658,8 @@ export class FTRumWebSocketTracking {
         webSocketHandshakeState,
       };
       if (error?.message) resource.errorMessage = error.message;
-      const metrics: { duration?: number } = {};
-      if (duration !== undefined) metrics.duration = duration;
       if (isCurrentLifecycle()) {
-        await resourceReporter.addResource(
-          resourceKey,
-          resource,
-          Object.keys(metrics).length ? metrics : undefined
-        );
+        await resourceReporter.addResource(resourceKey, resource, timing);
       }
     } catch {
       if (isCurrentLifecycle()) {
@@ -679,7 +674,7 @@ export class FTRumWebSocketTracking {
     key: string,
     started: Promise<boolean>,
     content: NativeWebSocketResource,
-    duration: number | undefined,
+    timing: WebSocketTimingMetrics | undefined,
     error?: WebSocketHandshakeError,
     errorReady?: Promise<void>
   ): Promise<void> {
@@ -703,7 +698,7 @@ export class FTRumWebSocketTracking {
       await session.addResource(
         key,
         error?.message ? { ...content, errorMessage: error.message } : content,
-        duration === undefined ? {} : { duration }
+        timing ?? {}
       );
     } catch {
       session.release(key);

package/src/specs/NativeFTMobileReactNative.ts

@@ -41,6 +41,7 @@ export interface Spec extends TurboModule {
    * @returns a Promise.
    */
   unbindRUMUserData(): Promise<void>;
+  resetVisitorId(): Promise<void>;
   /**
    * Add custom global parameters. Applies to RUM and Log data
    * @param context custom global parameters.