The NavigationTrackingOptions object allows you to override default tracking behavior using three optional predicate functions:

1. viewNamePredicate (ViewNamePredicate): Determines the name of the view sent to RUM.
   • Default: Forwards the view name directly to RUM.
2. viewTrackingPredicate (ViewTrackingPredicate): Determines if a specific route should be tracked as a view.
   • Default: Tracks all views.
3. paramsTrackingPredicate (ParamsTrackingPredicate): Determines which navigation parameters are forwarded to RUM. This is useful for filtering or masking sensitive data.
   • Default: Does not forward any parameters to RUM.

import { Route } from "@react-navigation/native";
import { 
  ViewNamePredicate, 
  ViewTrackingPredicate, 
  ParamsTrackingPredicate 
} from '@datadog/mobile-react-navigation';

// Custom view name
const viewNamePredicate: ViewNamePredicate = (route: Route<string, any>, trackedName: string) => {
  return "My custom View Name";
};

// Filter views (e.g., ignore modals)
const viewTrackingPredicate: ViewTrackingPredicate = (route: Route<string, any>) => {
  return route.name !== "AlertModal";
};

// Mask or filter parameters
const paramsTrackingPredicate: ParamsTrackingPredicate = (route: Route<string, any>) => {
  const filteredParams: any = {};
  if (route.params?.username) {
    filteredParams["username"] = route.params.username;
  }
  // creditCardNumber is omitted or masked
  return filteredParams;
};

You can control the benchmark app using deep links to trigger specific scenarios or stop the current one.

Start a scenario

Use the start method with scenario (from the Scenario enum) and runType (instrumented|baseline|profiling).

iOS: xcrun simctl openurl booted "benchmark://start?scenario=navigation&runType=instrumented"

Android: adb shell am start -W -a android.intent.action.VIEW -d 'benchmark://start?scenario=navigation\&runType=instrumented' com.benchmarkrunner

Stop a scenario

Use the stop method to halt the current scenario.

iOS: xcrun simctl openurl booted "benchmark://stop"

Android: adb shell am start -W -a android.intent.action.VIEW -d 'benchmark://stop' com.benchmarkrunner

# iOS Start
xcrun simctl openurl booted "benchmark://start?scenario=navigation&runType=instrumented"

# Android Start
adb shell am start -W -a android.intent.action.VIEW -d 'benchmark://start?scenario=navigation\&runType=instrumented' com.benchmarkrunner

# iOS Stop
xcrun simctl openurl booted "benchmark://stop"

# Android Stop
adb shell am start -W -a android.intent.action.VIEW -d 'benchmark://stop' com.benchmarkrunner

To capture SVG images in your Session Replay recordings, you must configure the Datadog Babel and Metro plugins.

1. Install the Babel Plugin

npm install @datadog/mobile-react-native-babel-plugin
# or
yarn add @datadog/mobile-react-native-babel-plugin

2. Configure Babel

In your babel.config.js, add the @datadog/mobile-react-native-babel-plugin and set sessionReplay.svgTracking to true.

module.exports = {
  presets: ['module:@react-native/babel-preset'],
  plugins: [
    [
      '@datadog/mobile-react-native-babel-plugin',
      {
        sessionReplay: {
          svgTracking: true
        }
      }
    ]
  ]
};

3. Configure Metro

In your metro.config.js, wrap your existing configuration with withSessionReplayAssetBundler from @datadog/mobile-react-native-session-replay/metro.

// metro.config.js
const { withSessionReplayAssetBundler } = require('@datadog/mobile-react-native-session-replay/metro');

module.exports = withSessionReplayAssetBundler({
  /* your existing Metro config */
});

You can initialize the Datadog SDK and set up the OpenFeature provider using either manual initialization or the <DatadogProvider /> component.

Manual Initialization

Use this approach if you are managing the lifecycle of DdSdkReactNative manually.

Using <DatadogProvider />

Use this approach to wrap your application and handle initialization via the onInitialized callback.

Note: Sending flag evaluation data to Datadog is automatically enabled. You can configure this by passing rumIntegrationEnabled and trackExposures to the DdFlags.enable() call.

import { CoreConfiguration, DatadogProvider, DdFlags } from '@datadog/mobile-react-native';
import { DatadogOpenFeatureProvider } from '@datadog/mobile-react-native-openfeature';
import { OpenFeature } from '@openfeature/react-sdk';

// Example using <DatadogProvider />
<DatadogProvider
    configuration={coreConfiguration}
    onInitialized={async () => {
        await DdFlags.enable();

        const provider = new DatadogOpenFeatureProvider();
        OpenFeature.setProvider(provider);
    }}
>
    {/* ... */}
</DatadogProvider>

In SDK 3.0, the configuration structure has changed. Feature configuration is now split into feature-specific properties: rumConfiguration, logsConfiguration, and traceConfiguration.

Mandatory Fields:

• clientToken, environment, and trackingConsent are mandatory for Core SDK initialization.
• applicationId is mandatory for RUM to work.

Important Behavior Change: Unlike v2.x, v3 will not initialize or enable a feature module if no configuration is provided for it.

const config = new CoreConfiguration(
    CLIENT_TOKEN,
    ENVIRONMENT,
    TrackingConsent.GRANTED,
    {
    rumConfiguration: {
        applicationId: APPLICATION_ID,
        trackInteractions: true,
        trackResources: true,
        trackFrustrations: true,
        sessionSampleRate: 100,
        telemetrySampleRate: 100
    }
    },
    logsConfiguration: {
        logEventMapper: (logEvent) => {
            logEvent.message = `[CUSTOM] ${logEvent.message}`;
            return logEvent;
        }
    },
    traceConfiguration: {}
});

await DdSdkReactNative.initialize(config);