@dynatrace/react-native-plugin 2.343.1 → 2.347.1

package/README.md

@@ -35,8 +35,8 @@ If you want to start using this plugin and are not a Dynatrace customer yet, hea
 ## Agent Versions
 These agent versions are configured in this plugin:
 
-* Android Agent: 8.343.1.1038
-* iOS Agent: 8.343.1.1007
+* Android Agent: 8.347.1.1003
+* iOS Agent: 8.347.1.1004
 
 ## Quick Setup
 
@@ -48,36 +48,36 @@ These agent versions are configured in this plugin:
 
 ## Advanced topics
 * [Manual OneAgent Startup](#manual-oneagent-startup)
-* [Manual instrumentation](#manual-instrumentation)
-  * [Plugin Startup](#plugin-startup)
+* [Real User Monitoring (RUM)](#real-user-monitoring-rum)
+  * [User Interaction](#user-interaction)
+  * [Send Event](#send-event)
+  * [Send Session Property Event](#send-session-property-event)
+  * [Event Modifier](#event-modifier)
+  * [Send Exception Event](#send-exception-event)
+  * [Send HTTP Request Event](#send-http-request-event)
+  * [View Monitoring](#view-monitoring)
+  * [App start user action](#app-start-user-action)
+  * [React Native Symbolication](#react-native-symbolication)
+* [RUM Classic](#rum-classic)
   * [Monitor a Component](#monitor-a-component)
   * [Create Custom Action](#create-custom-actions)
   * [Cancel Actions](#cancel-actions)
   * [Manual Web Request Tagging](#manual-web-request-tagging)
   * [Report Values](#report-values)
   * [Report Stacktrace](#report-an-error-stacktrace)
-  * [Identify User](#identify-a-user)
-  * [End Session](#end-the-current-user-session)
   * [Crash Reporting](#manually-report-a-crash)
-  * [User Privacy Options](#user-privacy-options)
   * [Report GPS Position](#report-gps-location)
   * [Business event capturing](#business-event-capturing)
   * [Platform independent reporting](#platform-independent-reporting)
   * [Set beacon headers](#setting-beacon-headers)
   * [Exclude Individual JSX Elements](#exclude-individual-jsx-elements)
-* [New RUM experience](#new-rum-experience)
-  * [User Interaction](#user-interaction)
-  * [Send Event](#send-event)
-  * [Send Session Property Event](#send-session-property-event)
-  * [Event Modifier](#event-modifier)
-  * [Send Exception Event](#send-exception-event)
-  * [Send HTTP Request Event](#send-http-request-event)
-  * [View Monitoring](#view-monitoring)
-  * [React Native Symbolication](#react-native-symbolication)
+* [Extended topics](#extended-topics)
+  * [Identify User](#identify-a-user)
+  * [End Session](#end-the-current-user-session)
+  * [User Privacy Options](#user-privacy-options)
 * [NPX Commands](#npx-commands)
   * [npx instrumentDynatrace](#npx-instrumentdynatrace)
   * [npx configDynatrace](#npx-configdynatrace)
-  * [npx lineOffsetDynatrace](#npx-lineoffsetdynatrace)
 * [Customizing paths for configuration](#customizing-paths-for-configuration)
 * [Manual adding iOS Agent to project](#manually-adding-ios-oneagent-to-a-project)
 * [Setup for tvOS](#setup-for-tvos)
@@ -91,10 +91,8 @@ These agent versions are configured in this plugin:
     * [Autostart](#autostart)
     * [Bundle Name and Version](#bundle-name-and-version)
     * [Navigation](#navigation)
-    * [Source Map](#source-map)
     * [User Interaction Configuration](#user-interaction-configuration)
     * [Debugging our auto-instrumentation](#debugging-our-auto-instrumentation)
-    * [Using our legacy jscodeshift auto-instrumentation](#using-our-legacy-jscodeshift-auto-instrumentation)
   * [Android block](#android-block)
   * [iOS block](#ios-block)
   * [Lifecycle modes](#lifecycle)
@@ -221,31 +219,7 @@ module.exports = {
 };
 ```
 
-2. Make the start-up call with at least `beaconUrl` and `applicationId`:
-
-Example of a startup call:
-
-```ts
-import { Dynatrace, ConfigurationBuilder } from '@dynatrace/react-native-plugin';
-
-await Dynatrace.start(new ConfigurationBuilder("beaconUrl", "applicationId").buildConfiguration());
-```
-
-For more details see the section about [startup API](#plugin-startup).
-
-**Note**: If you don't deactivate the automated startup with the `dynatrace.config.js` file, the `beaconUrl` and `applicationId` values have no impact and are thrown away.
-
-## Manual instrumentation
-
-To use the API of the React Native plugin, import the API:
-
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
-```
-
-### Plugin startup
-
-The manual startup of the plugin is triggered via the `start(configuration: IConfiguration)` method. If you configured `dynatrace.config.js` for manual startup then the plugin doesn't send any data when not calling this function. Besides the application id and the beacon URL, there are several optional configuration parameters, which are shown in the table below. 
+2. Call `Dynatrace.start()` with your configuration. The startup call is triggered via the `start(configuration: IConfiguration)` method — if you configured `dynatrace.config.js` for manual startup, the plugin doesn't send any data until this function is called. At minimum you need `beaconUrl` and `applicationId`, but there are several optional configuration parameters as well:
 
 ```ts
 import { Dynatrace, ConfigurationBuilder, LogLevel } from '@dynatrace/react-native-plugin';
@@ -265,6 +239,8 @@ configurationBuilder.withCrashReporting(true)
 await Dynatrace.start(configurationBuilder.buildConfiguration());
 ```
 
+**Note**: If you don't deactivate the automated startup with the `dynatrace.config.js` file, the `beaconUrl` and `applicationId` values have no impact and are thrown away.
+
 **Info**: The value used in the function calls for the parameters is also their default value.
 
 | Property name           | Type   | Default     | Description                                       |
@@ -282,866 +258,899 @@ await Dynatrace.start(configurationBuilder.buildConfiguration());
 |actionNameAlgorithm      |string  |'depth-first'        |Controls the traversal algorithm used when searching the component tree for the name of an `onPress` action. `'depth-first'` follows the first child branch fully before trying siblings. `'breadth-first'` visits all siblings at a level before going deeper, returning the shallowest match first.|
 |bundleName               |string  |undefined    |Should be used only if you have a multiple bundle setup where you load several .bundle files within your React Native application. Enter the name of your bundle. This should be unique in comparison to your other bundle names. This will ensure that actions coming from different bundles will not interfere with each other.
 
-**Attention:** 
+**Attention:**
 * Keep in mind that configuration within the `dynatrace.config.js` file is the basis, even for manual startup. When we look at the lifecycleUpdate property: Per default if not used, it is false. If enabled (set to true) in `dynatrace.config.js` file, this will be also true if manual startup is used. You can still override this behavior by calling `ConfigurationBuilder.withLifecycleUpdate(false)`.
 * Please use those parameters only when doing a manual startup. If you want to do an automated startup, please configure the properties via the [auto startup configuration](#manual-startup-counterparts). You will find a list which explains all the counterparts for the available options here.
 
-### Monitor a Component
+## Real User Monitoring (RUM)
 
-A component can be either monitored automatically or manually. The auto instrumentation is handled via the dynatrace.config.js file. If you want to manually instrument a component you can use the API call `withMonitoring`.
+Real User Monitoring introduces a set of advanced APIs that allow you to send custom events, modify event data, track exceptions, monitor HTTP requests, and manage view contexts in your React Native application. These APIs provide more granular control over the data captured by Dynatrace and are designed for the next generation RUM capabilities.
 
-* Example with Functional Component:
+For more detailed information about Real User Monitoring, see the [official Dynatrace documentation](https://docs.dynatrace.com/docs/shortlink/react-native-main).
 
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
-import { FunctionComponent } from 'react';
+### Send Event
 
-export const MyFunctionalComponent: FunctionComponent<{}> = () => {
-  return null;
-}
+The `sendEvent()` method allows you to send custom events with arbitrary properties using the EventData class. This is useful for tracking specific user interactions or application state changes.
 
-Dynatrace.withMonitoring(MyFunctionalComponent, "MyFunctionalComponent");
+```ts
+import { Dynatrace, EventData } from '@dynatrace/react-native-plugin';
+
+// Send a custom event with properties
+Dynatrace.sendEvent(new EventData()
+  .addEventProperty("event_properties.button_clicked", "login_button")
+  .addEventProperty("event_properties.user_type", "premium")
+  .addEventProperty("event_properties.attempt_count", 3)
+  .withDuration(250)
+);
 ```
-![rnFunctionalComp](https://dt-cdn.net/images/rnfunctionalcomp-800-d98eacef6d.png)
 
-The String "MyFunctionalComponent" is optional as the name of the component can be retrieved through [different properties](#how-does-dynatrace-determine-the-user-action-name).
+**Property Requirements:**
+* Only properties prefixed with `event_properties.*` are allowed
+* Additionally, the `duration` property is allowed
+* Maximum of 50 custom properties per event
+  * If the limit is exceeded, properties are sorted alphabetically by key and excess properties are dropped deterministically
+* String properties are limited to 5000 characters (exceeding characters are truncated)
+* Field names must contain only alphabetic characters, numbers, underscores, and dots
+* Each dot must be followed by an alphabetic character
+* Each underscore must be followed by an alphabetic character or number
+* Values must be primitive types (string, number, boolean)
+* Cannot contain functions, undefined, Infinity, or NaN as values (they will be replaced with null)
 
-Combining manual and auto instrumentation should not be a problem. As they're running the same execution, the manual instrumentation will only override the content of auto instrumentation happening through the transformer.
+### Send Session Property Event
 
-### Create custom actions
+Session properties apply to all events within the current session. Use `sendSessionPropertyEvent()` to set properties that should be available across the entire user session.
 
-There are two options to create an action. Either using `enterAutoAction` (the previous `enterAction`) or `enterManualAction`:
+```ts
+import { Dynatrace, SessionPropertyEventData } from '@dynatrace/react-native-plugin';
 
-**Important:** Action names are limited to 250 characters and will be truncated if they exceed this limit.
+// Set session-wide properties
+Dynatrace.sendSessionPropertyEvent(new SessionPropertyEventData()
+  .addSessionProperty("session_properties.user_tier", "premium")
+  .addSessionProperty("session_properties.app_version", "2.1.0")
+  .addSessionProperty("session_properties.feature_flag_enabled", true)
+);
+```
 
-* `enterAutoAction` - Creates an Action which will be automatically handled by the plugin (This is the type of action which is internally used by the plugin when monitoring components and touchables). This means that the plugin decides about the hierarchy of this action. If there is no open action, the following action will be a root action. All other actions created by this method, while a root action is open, will be automatically inserted as a child action. Furthermore the plugin will automatically link webrequest (if they are not tagged manually) to the open root action. Be aware that the timeout/wait time for sub actions or web requests cannot be modified on the Android side for React Native Auto actions. The timeout is fixed to a 1000ms.
+**Important Notes:**
+* Session properties persist throughout the entire session
+* If you send the same property multiple times, only one value will be kept (first or last)
+* Use session properties for data that applies to the entire user session
+* Field naming follows the same rules as events, but with `session_properties.` prefix
+* Maximum of 50 custom properties per event
+  * If the limit is exceeded, properties are sorted alphabetically by key and excess properties are dropped deterministically
 
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+### Event Modifier
 
-const myAction = Dynatrace.enterAutoAction("MyButton tapped");
-//Perform the action and whatever else is needed.
-myAction.leaveAction();
-```
-![rnSingle](https://dt-cdn.net/images/rnsingle-800-e7e1b343ed.png)
+Event modifiers allow you to intercept and modify events before they are sent to Dynatrace. This is useful for adding common properties, filtering sensitive data, or enriching events with additional context. Event modifiers apply to all event types, including custom events, session properties, exceptions, and HTTP events.
 
-* `enterManualAction` - Creates an Action which will NOT be handled by the plugin. This means that you have full control about the hierarchy of your actions. This function will create a root action for you, which has the ability to create child actions via `enterAction`. Be aware, because of the full manual approach the plugin will not link webrequest automatically. Webrequest have to be manually tagged by using the tag provided by the action via `getRequestTag`.
+If multiple event modifiers are added, they are executed in the order they were added.
 
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+Most fields and namespaces can't be modified in any way (added, removed or overridden), while others are open for modification.
 
-const myAction = Dynatrace.enterManualAction("MyButton tapped");
-//Perform the action and whatever else is needed.
-myAction.leaveAction();
-```
+**Open for modification and can be added:**
+- `event_properties.*`
+- `session_properties.*`
 
-To create a custom action named `"MyButton tapped"`, use the following code. The *leaveAction* closes the action again. To report values for this action before closing, see [Report Values](#report-values).
+`session_properties.*` are only allowed to be on a session property event.
+
+**Open for modification only:**
+- `url.full`
+- `exception.stack_trace`
+
+#### Example
 
 ```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+import { Dynatrace, IEventModifier } from '@dynatrace/react-native-plugin';
 
-const myAction = Dynatrace.enterAutoAction("MyButton tapped");
-//Perform the action and whatever else is needed.
-myAction.leaveAction();
+// Create an event modifier
+const myModifier: IEventModifier = {
+  modifyEvent(event) {
+    // Add common properties to all events
+    event["event_properties.app_build"] = "1.2.3";
+    event["event_properties.environment"] = "production";
+    
+    // Return null to discard the event entirely
+    if (event["event_properties.ignore"] === true) {
+      return null;
+    }
+    
+    return event;
+  }
+};
+
+// Add the modifier
+Dynatrace.addEventModifier(myModifier);
+
+// Remove the modifier when no longer needed
+Dynatrace.removeEventModifier(myModifier);
 ```
 
-### Create custom sub actions
+#### Important Considerations
 
-You can create a single custom action as well as sub actions. The `MyButton Sub Action` is automatically put under the `MyButton tapped`. As long as `MyButton tapped` is open, it gathers all the web requests.
+- **Execution order**: If multiple event modifiers are added, they are executed in the order they were added
+- **Returning null**: Returning `null` discards the event and prevents future modifier functions from being executed
+- **Performance**: Event modifiers should be efficient as they are called for every event
+- **Field naming**: Custom properties must follow the `event_properties.*` or `session_properties.*` prefix naming convention
+- **Reserved fields**: Certain reserved fields and namespaces cannot be modified. Attempts to modify them will be ignored
+- **Error handling**: If a modifier throws an exception, it will be logged but won't prevent other modifiers from executing
+- **Primitive values**: Event fields can only contain primitive values (String, int, double, bool)
+- **Invalid argument**: In case you pass an invalid argument to `addEventModifier`, we return a no-op placeholder modifier.
 
-**Important:** Action names are limited to 250 characters and will be truncated if they exceed this limit.
+### Send Exception Event
+
+The `sendExceptionEvent()` method provides a structured way to report exceptions with additional context and custom properties using the ExceptionEventData class.
 
 ```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+import { Dynatrace, ExceptionEventData } from '@dynatrace/react-native-plugin';
 
-const myAction = Dynatrace.enterManualAction("MyButton tapped");
-const mySubAction = myAction.enterAction("MyButton Sub Action");
-//Perform the action and whatever else is needed.
-mySubAction.leaveAction();
-myAction.leaveAction();
+try {
+  // Code that may throw an error
+  throw new Error('Something went wrong');
+} catch (error) {
+  if (error instanceof Error) {
+    Dynatrace.sendExceptionEvent(new ExceptionEventData(error)
+      .addEventProperty('event_properties.custom_key', 'custom_value')
+      .addEventProperty('event_properties.error_context', 'user_action')
+    );
+  }
+}
 ```
-![subAction](https://dt-cdn.net/images/subaction-800-172dbcca6c.png)
 
-### Cancel actions
+**Parameters:**
+* `error`: The Error object containing exception information (required)
 
-Actions can be canceled. That means they will not be sent and discarded fully. This also means that any values and sub actions attached to the action will be removed. 
+### Send HTTP Request Event
+
+The `sendHttpRequestEvent()` method allows you to manually report HTTP request events with detailed information about the request and response.
 
 ```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
 
-const myAction = Dynatrace.enterAutoAction("MyButton tapped");
-// Action will be canceled
-myAction.cancel();
+// Basic HTTP request event
+const requestEventData = new HttpRequestEventData('https://api.example.com/users', 'GET');
+Dynatrace.sendHttpRequestEvent(requestEventData);
 
-// Has no impact as the action is already canceled
-myAction.leaveAction();
+// HTTP request with additional details
+const detailedRequestEventData = new HttpRequestEventData('https://api.example.com/data', 'POST')
+  .withStatusCode(200)
+  .addEventProperty('event_properties.headers.content_type', 'application/json');
+Dynatrace.sendHttpRequestEvent(detailedRequestEventData);
 ```
 
-### Manual Web Request Tagging
+**Parameters:**
+* `url`: The URL of the HTTP request (required)
+* `method`: The HTTP method (e.g., 'GET', 'POST', 'PUT', 'DELETE') (required)
 
-You can manually tag and time your web requests. With the API shown below, you are able to manually capture the web requests of an http framework/library. 
+### View Monitoring
 
-**Note:** 
-Using this API will force the request to be added to the action that is manually created. 
+The view monitoring APIs allow you to track different screens or views in your application, providing context for all events happening within those views.
 
-```ts
-import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin';
+There are two ways to monitor views:
+1. **Automatic view monitoring** - Enable navigation tracking in your configuration to automatically capture view changes through supported navigation libraries (enabled by default)
+2. **Manual view monitoring** - Use the `startView()` API to manually control when view contexts are created and updated
 
-const action = Dynatrace.enterManualAction('API Data Fetch');
-const url = 'https://api.example.com/data';
-const tag = await action.getRequestTag(url);
-const timing = new DynatraceWebRequestTiming(tag, url);
+> **Important:** These approaches should not be mixed, as the outcome is unpredictable. Choose either automatic or manual view monitoring for your application.
 
-try {
-  timing.startWebRequestTiming();
-  const response = await fetch(url, {
-    headers: {
-      [timing.getRequestTagHeader()]: tag
-    }
-  });
-  timing.stopWebRequestTiming(response.status, response.statusText);
-} catch (error) {
-  if (error instanceof Error) {
-    timing.stopWebRequestTiming(-1, error.message);
-  } else {
-    timing.stopWebRequestTiming(-1, (error as any).toString());
+#### Automatic Navigation tracking
+
+> **Note:** This feature only works with `@react-navigation` versions 5.x through 7.x.
+
+The following is an example of how this feature can be configured in your `dynatrace.config.js` file. Note that this feature is enabled by default.
+
+```js
+react: {
+  navigation: {
+    enabled: true
   }
-} finally {
-  action.leaveAction();
 }
 ```
-![rnManualWeb](https://dt-cdn.net/images/rnmanualweb-800-662d009613.png)
 
-There is also the option to report values for request and response size:
+When this feature is enabled, the view context will represent the current state of the `@react-navigation` `NavigationContainer`. The state gets represented as a URL-style route. All subsequent events get associated with the view context and thus with the current route.
 
-```ts
-import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin';
+For instance, assume the following setup:
+```js
+const Drawer = createDrawerNavigator();
 
-const action = Dynatrace.enterManualAction('API Data Upload');
-const url = 'https://api.example.com/upload';
-const tag = await action.getRequestTag(url);
-const timing = new DynatraceWebRequestTiming(tag, url);
-const requestData = JSON.stringify({ key: 'value' });
+function App() {
+  return (
+    <NavigationContainer>
+      <Drawer.Navigator initialRouteName="Home">
+        <Drawer.Screen name="Home" component={HomeScreen} />
+        <Drawer.Screen name="Feature" component={FeatureScreen}/>
+      </Drawer.Navigator>
+    </NavigationContainer>
+  );
+}
 
-try {
-  timing.startWebRequestTiming();
-  const response = await fetch(url, {
-    method: 'POST',
-    headers: {
-      [timing.getRequestTagHeader()]: tag,
-      'Content-Type': 'application/json'
-    },
-    body: requestData
-  });
-  const responseData = await response.text();
-  timing.stopWebRequestTimingWithSize(
-    response.status,
-    response.statusText,
-    requestData.length,
-    responseData.length
+const Stack = createStackNavigator();
+
+function FeatureScreen() {
+  return (
+    <Stack.Navigator initialRouteName="ScreenOne">
+      <Stack.Screen name="ScreenOne" component={NestedScreenOne} />
+      <Stack.Screen name="ScreenTwo" component={NestedScreenTwo} />
+    </Stack.Navigator>
   );
-} catch (error) {
-  if (error instanceof Error) {
-    timing.stopWebRequestTiming(-1, error.message);
-  } else {
-    timing.stopWebRequestTiming(-1, (error as any).toString());
-  }
-} finally {
-  action.leaveAction();
 }
 ```
-![rnBytes](https://dt-cdn.net/images/rnbytes-800-139042060c.png)
 
-### Report values
+When navigating to `Home`, the view context will be set to `/Home`. When navigating to `Feature` and being redirected to the nested `ScreenOne`, the view context will be set to `/Home/ScreenOne`.  When navigating to `ScreenTwo` within `Feature`, the view context will be set to `/Feature/ScreenTwo`.
 
-For any open action you can report certain values. The following API is available for action:
+#### Start View
+
+Use `startView()` to begin monitoring a specific view or screen. When a view is started, all subsequent events will be associated with that view context.
 
 ```ts
-import { Platform } from '@dynatrace/react-native-plugin';
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-interface IDynatraceAction {
-  reportDoubleValue(valueName: string, value: number, platform?: Platform): void;
-  reportError(errorName: string, errorCode: number, platform?: Platform): void;
-  reportEvent(eventName: string, platform?: Platform): void;
-  reportIntValue(valueName: string, value: number, platform?: Platform): void;
-  reportStringValue(valueName: string, value: string, platform?: Platform): void;
-}
+// Start monitoring a view
+Dynatrace.startView("HomeScreen");
 ```
 
-**Important:** All string parameters (errorName, eventName, valueName, value) are limited to 250 characters and will be truncated if they exceed this limit.
+**Important Considerations:**
+* Only one view can be active at a time
+* Starting a new view will automatically stop the previous one
+* View names should be meaningful and consistent across your application
+* All events captured after starting a view will include the view context
 
-To report a string value, use the following:
+**Complete Example:**
 
 ```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+import { Dynatrace, EventData } from '@dynatrace/react-native-plugin';
 
-const myAction = Dynatrace.enterAutoAction("MyButton tapped");
-myAction.reportStringValue("ValueName", "ImportantValue");
-myAction.leaveAction();
-```
-![rnReportString](https://dt-cdn.net/images/rnreportstring-800-739e5ba752.png)
+// User navigates to profile screen
+Dynatrace.startView("UserProfile");
 
-If you look at the API calls, you will see the optional parameter `platform?: Platform`. This parameter offers the possibility to report values only for a specific platform. to know more, see [Platform independent reporting](#platform-independent-reporting).
+// Send custom event within the view
+Dynatrace.sendEvent(new EventData()
+  .addEventProperty("event_properties.profile_action", "edit_profile")
+  .addEventProperty("event_properties.changes_made", true)
+);
 
+// User navigates away
+Dynatrace.startView("UserProfileDetailed");
+```
 
-### Report an error stacktrace
+### User Interaction
 
-To manually report an error stacktrace, use the following API call:
+User Interaction is an automatic instrumentation feature that captures touch and press events in your React Native application without requiring any manual API calls. When enabled, the plugin instruments your UI components at build time and sends structured interaction events to Dynatrace at runtime.
 
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+The following is an example of how this feature can be configured in your `dynatrace.config.js` file. Note that this feature is enabled by default.
 
-try {
-  throw new Error('Database connection failed');
-} catch (error) {
-  if (error instanceof Error) {
-    Dynatrace.reportErrorStacktrace(
-      'DatabaseError',
-      error.message,
-      'Failed to connect to remote database',
-      error.stack || 'No stack trace available'
-    );
-  }
+```js
+react: {
+  userInteraction: true
 }
 ```
-![rnStack](https://dt-cdn.net/images/rnstack-800-26c6ac7408.png)
-
-**Note:**
-The previous API without *errorValue* is deprecated and will be removed in the future. Please use the new API with errorValue if possible.
 
-### Identify a user
+When enabled, UI Interaction can be controlled by two layers:
 
-You can identify a user and tag the current session with a name by making the following call:
+1. **Build/config layer (`dynatrace.config.js`)**
+  - `react.userInteraction: true|false` controls whether the UI Interaction instrumentation feature is applied.
 
-**Important:** The user identifier is limited to 250 characters and will be truncated if it exceeds this limit.
+2. **Runtime remote layer**
+  - CP always forwards User Interaction Actions (UIA) to the native agent unconditionally. The native agent decides whether to record or discard each UIA based on its own remote configuration (e.g. `touch_interaction_enabled`).
 
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+#### Masking sensitive UI labels
 
-Dynatrace.identifyUser("User XY");
-```
-![rnTag](https://dt-cdn.net/images/rntag-800-77fe848023.png)
+UI Interaction also supports masking sensitive labels before events are sent.
 
-### End the current user session
+Masking is applied when:
 
-To end the current user session, use the following API call:
+* the touched element or one of its parents is marked with `dtMask`
+* the runtime masking rules classify the detected text as sensitive
+* the runtime masking rules classify the element `testID` as sensitive
 
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+When masking is active:
 
-Dynatrace.endSession();
-```
+* the interaction path and component information are still reported
+* the detected UI label is replaced with the configured replacement string (default: `***`)
+* `ui_element.name_origin` is reported as `masked`
 
-**Note:** The user tagging will not carry over to the new user session that is started after using this API. If user tagging is desired in the new user session, please ensure that you call the [user tagging](#identify-a-user) API.
+Example using `dtMask`:
 
-### Manually report a crash
+```tsx
+<View dtMask>
+  <Pressable onPress={onPress}>
+    <Text>john.doe@example.com</Text>
+  </Pressable>
+</View>
+```
 
-You can manually report a crash via the following API calls:
+This allows you to preserve interaction analytics while avoiding exposure of sensitive text in the emitted UI Interaction event.
 
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-try {
-  throw new Error('Fatal memory allocation failure');
-} catch (error) {
-  if (error instanceof Error) {
-    Dynatrace.reportCrash(
-      'MemoryError',
-      error.message,
-      error.stack || 'No stack trace available'
-    );
+#### Produced data
 
-    // or directly via the full error
-    Dynatrace.reportCrashWithException('MemoryError', error);
-  }
-}
-```
-![rnCrash](https://dt-cdn.net/images/rncrash-800-3e7391140f.png)
+Each captured interaction produces an event describing what the user touched and where. The event includes:
 
-> **Note**: If you use this API call to report a crash manually, it will force the session to be completed. Any new actions that are captured afterwards will be added into a new session.
+- **Detected name** — the resolved label of the touched element, derived from its visible text, accessibility label, component name, or test ID.
+- **Component** — the type of the UI component that was touched (e.g. `Pressable`).
+- **Component Path** — a stable path through the component tree that uniquely identifies the element (e.g. `App/View[1]/Pressable[1]`).
+- **Interaction type** — how the user interacted (e.g. `touch`).
+- **Position** — the screen coordinates where the touch occurred.
 
-*reportCrashWithException* will use the crashName as name for the crash. It will only report the crash if there is also a stacktrace available. 
+In some cases, a **responder** is also included. The responder is the component that ultimately handled the user's touch — for example, a `Pressable` that received the press event. It carries the same name, component type, and path information as the touched element, and can differ when a touch is visually on a child element but handled by a parent.
 
-### User Privacy Options
+If masking is active for an interaction, the event still contains the same structural information, but the detected name is replaced and the name origin changes to `masked`.
 
-The privacy API methods allow you to dynamically change the data-collection level based on the individual preferences of your end users. Each end user can select from three data-privacy levels:
+#### Example event
 
-```ts
-export enum DataCollectionLevel {
-    Off, Performance, UserBehavior
+```json
+{
+  "characteristics.has_user_interaction": true,
+  "ui_element.detected_name": "LoginButton",
+  "ui_element.components": ["Pressable"],
+  "ui_element.id": "App/View/Pressable",
+  "ui_element.name_origin": "component",
+  "interaction.type": "touch",
+  "positions": [{ "x": 120, "y": 460 }],
+  "ui_element.responder.detected_name": "Pressable",
+  "ui_element.responder.components": ["Pressable"],
+  "ui_element.responder.id": "App/View[/Pressable",
+  "ui_element.responder.name_origin": "component"
 }
 ```
 
-1. Off: Native Agent doesn't capture any monitoring data.
-2. Performance: Native Agent captures only anonymous performance data. Monitoring data that can be used to identify individual users, such as user tags and custom values, aren't captured.
-3. UserBehavior: Native Agent captures both performance and user data. In this mode, Native Agent recognizes and reports users who re-visit in future sessions.
+#### Custom Names for Components
 
-Crash reporting is enabled by default. The Mobile agent captures all unhandled exceptions/errors and immediately sends the crash report to the server. With this API you can activate or deactivate crash reporting. To change this behaviour via the API, enable/activate [`userOptIn`](#user-opt-in-mode) and set the User Privacy Options.
+You can assign custom names to your components. A custom name affects both the **Component** and the **Component Path** described above. There are two ways to do this, depending on how the component is used.
 
-The API to get and set the current privacy level looks like this:
+##### 1. As a JSX prop (`dtActionName`)
 
-```ts
-import { Platform, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+Use this when you render the component as JSX. Pass `dtActionName` as a prop, and it overrides the auto-detected name for that specific usage:
 
-interface IDynatrace {
-  getUserPrivacyOptions(platform?: Platform): Promise<UserPrivacyOptions>;
-  applyUserPrivacyOptions(userPrivacyOptions: UserPrivacyOptions, platform?: Platform): void;
-}
+```tsx
+<TouchableOpacity dtActionName="Checkout Button" onPress={onCheckout}>
+    <Text dtActionName="Checkout Text">Buy now</Text>
+</TouchableOpacity>
 ```
 
-To check the current privacy options that are set:
-
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+Touching it produces:
 
-const privacyOptions = await Dynatrace.getUserPrivacyOptions();
+```json
+"ui_element.components": ["Checkout Text"],
+"ui_element.id": ".../Checkout Button/Checkout Text"
 ```
 
-If you want to create a new `UserPrivacyOptions` object and pass it to Dynatrace:
-
-```ts
-import { Dynatrace, DataCollectionLevel, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+##### 2. As a static property (`Component.dtActionName`)
 
-const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.UserBehavior, true);
+Use this when the component is **not** rendered as JSX, so the prop approach above is not available — for example, a screen component you define once and hand to a navigator by reference. Set `dtActionName` directly on the component. This affects **every** place the component is used at once:
 
-// Getter and setter available for UserPrivacyOptions
-privacyConfig.crashReportingOptedIn = false;
-privacyConfig.dataCollectionLevel = DataCollectionLevel.Performance;
+```tsx
+import { NavigationContainer } from '@react-navigation/native';
+import { createDrawerNavigator } from '@react-navigation/drawer';
 
-const level = privacyConfig.dataCollectionLevel;
-const crashReporting = privacyConfig.crashReportingOptedIn;
+const Drawer = createDrawerNavigator();
 
-Dynatrace.applyUserPrivacyOptions(privacyConfig);
-```
+function ProfileScreen() {
+    return (/* ... */);
+}
 
-### Report GPS Location
+// Applies to all usages of ProfileScreen below
+ProfileScreen.dtActionName = 'User Profile';
 
-You can report latitude and longitude and specify an optional platform. 
+function App() {
+    return (
+        <NavigationContainer>
+            <Drawer.Navigator>
+                {/* Both screens reference the same component,
+                    so both pick up the 'User Profile' name */}
+                <Drawer.Screen name="Me" component={ProfileScreen} />
+                <Drawer.Screen name="Account" component={ProfileScreen} />
+            </Drawer.Navigator>
+        </NavigationContainer>
+    );
+}
+```
 
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+Touches inside one of the 2 screens now produce:
 
-Dynatrace.setGPSLocation(48.31518732698596, 14.305245274594471);
+```json
+"ui_element.id": ".../User Profile/..."
 ```
 
-### Platform independent reporting
+> **Note:** The static property applies to *all* uses of the component. If you need a different name per usage, render the component as JSX and use the `dtActionName` prop (option 1) instead.
+>
+> **Note:** The static property has no effect when a component is rendered as JSX. In that case the name is taken from either the `dtActionName` prop passed to it (option 1) or the name of the JSX component.
 
-You probably noticed that each method has an additional *optional* parameter named `platform` of type `Platform`. You can use this to only trigger manual instrumentation for a specific OS. The available values are: `Platform.Ios` and `Platform.Android`. Default is that it will work on any platform. Otherwise it is passed *only* to the relevant OS. For example:
- * Passing to **iOS** only:
-```ts
-import { Dynatrace, Platform } from '@dynatrace/react-native-plugin';
+### App start user action
 
-const myAction = Dynatrace.enterAutoAction("MyButton tapped", Platform.Ios);
-//Perform the action and whatever else is needed.
-myAction.leaveAction(Platform.Ios); 
-```
- 
- * Passing to **Android** only:
-```ts
-import { Dynatrace, Platform } from '@dynatrace/react-native-plugin';
+OneAgent automatically creates a user action for each app start. The action starts at the first measured React Native startup phase (`runJsBundleStart`) and ends when `contentAppeared` fires — once the JavaScript bundle has loaded and the first content is displayed. The action groups all web requests, navigations, and errors that occur during startup.
 
-const myAction = Dynatrace.enterAutoAction("MyButton tapped", Platform.Android);
-//Perform the action and whatever else is needed.
-myAction.leaveAction(Platform.Android); 
-```
- 
- * Passing to **both**:
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+**Startup phases captured (in order):**
 
-const myAction = Dynatrace.enterAutoAction("MyButton tapped");
-//Perform the action and whatever else is needed.
-myAction.leaveAction(); 
-```
+| Phase | Android | iOS |
+|---|---|---|
+| `downloadStart` / `downloadEnd` | Dev mode only (Metro bundle download) | Not captured |
+| `runJsBundleStart` / `runJsBundleEnd` | Yes | Yes |
+| `contentAppeared` | Yes | Yes |
 
-### Business event capturing
+> **Note:** Unlike Android and iOS native agents, the React Native plugin does not distinguish cold, warm, and hot start types — the native SDK sets the start type when it receives the event.
 
-With `sendBizEvent`, you can report business events. These events are standalone events, as OneAgent sends them detached from user actions or user sessions.
+**Controlling the app start user action**
 
-For more information on business events, see [dynatrace documentation](https://docs.dynatrace.com/docs/observe/business-observability/explore-business-events).
+The app start user action is part of automatic user action detection and is controlled at runtime with `setAutomaticUserActionDetection`:
 
 ```ts
 import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-Dynatrace.sendBizEvent("com.easytravel.funnel.booking-finished", {
-  "event.name" : "Confirmed Booking",
-  "screen": "booking-confirmation",
-  "product": "Danube Anna Hotel",
-  "amount": 358.35,
-  "currency": "USD",
-  "reviewScore": 4.8,
-  "arrivalDate": "2022-11-05",
-  "departureDate": "2022-11-15",
-  "journeyDuration": 10,
-  "adultTravelers": 2,
-  "childrenTravelers": 0
-});
+// Disable all automatic user actions including the app start user action
+Dynatrace.setAutomaticUserActionDetection(false);
+
+// Re-enable
+Dynatrace.setAutomaticUserActionDetection(true);
 ```
-![rnBiz](https://dt-cdn.net/images/rnbiz-1262-f57a0a67f3.png)
 
-### Setting beacon headers
+This call applies to all automatic user actions (app start, touch/press interactions). To disable only touch interactions while keeping the app start user action, use `react.userInteraction: false` in `dynatrace.config.js` instead.
 
-This allows you to put a set of http headers on every agent http request (i.e. Authorization header etc.). It will also triggers the agent to reconnect to the beacon endpoint with the new headers. 
+For more details, see the [App start user action documentation](https://docs.dynatrace.com/docs/shortlink/react-native-app-performance#app-start-user-action).
 
-**Note:** To clear the previously set headers, call the method without the headers parameter or with a null value for the headers parameter.
+### React Native Symbolication
 
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+Dynatrace can automatically symbolicate JavaScript stack traces captured by the plugin using sourcemaps. This allows you to view human-readable file names, line numbers, and column information in your crash reports.
 
-const beaconHeaders = new Map<string, string>();
-beaconHeaders.set('headerName', 'headerValue');
-Dynatrace.setBeaconHeaders(beaconHeaders);
-```
+#### Generating Sourcemaps
 
-### Exclude Individual JSX Elements
+Sourcemaps are generated during release builds and map bytecode offsets (Hermes) and locations in the minified JavaScript bundle (JavaScriptCore) back to your original source code. We support sourcemaps for both Hermes and JavaScriptCore. For detailed instructions on generating sourcemaps, see the [React Native debugging release builds guide](https://reactnative.dev/docs/debugging-release-builds).
 
-If you want to instrument a functional component or class component but want to exclude a certain button or element, you can do this via the `dtActionIgnore` property. Example:
+To generate a sourcemap:
 
-```tsx
-import React from 'react';
-import { TouchableHighlight, Text, View } from 'react-native';
+**Android:**
+* Run `npx react-native run-android --mode release` in your project root, or
+* Run `gradlew assembleRelease` in the `/android` directory
 
-const TouchableHighlightScreen = () => {
-    return (
-        <View>
-            <TouchableHighlight onPress={onPress}>
-                <Text>TouchableHighlight that will be monitored</Text>
-            </TouchableHighlight>
-            <TouchableHighlight onPress={onPress} dtActionIgnore="true">
-                <Text>TouchableHighlight that will be ignored</Text>
-            </TouchableHighlight>
-        </View>
-    );
-};
+**iOS:**
+* First, enable sourcemaps according to the [React Native debugging release builds guide](https://reactnative.dev/docs/debugging-release-builds)
+* Then run `npx react-native run-ios --mode Release`, or
+* Build for release in Xcode
 
-const onPress = () => {
-    console.log("TouchableHighlight Pressed!");
-};
+#### Uploading Sourcemaps
 
-export default TouchableHighlightScreen;
-```
+Once generated, upload your sourcemaps to Dynatrace. For detailed instructions, see the [symbol file management documentation](https://docs.dynatrace.com/docs/observe/digital-experience/mobile-applications/analyze-and-use/upload-and-manage-symbol-files).
 
-This example shows two *TouchableHighlight*, which will fire the *onPress()* function when pressed. The property `dtActionIgnore="true"` will prevent the monitoring of one of them. This means that the onPress will still be executed but we will no longer create a user action which is wrapping the button click. 
+## RUM Classic
 
->*Attention:* If you are using Typescript and want to set this property with type-safety, look [here](#typescript-setup-for-dtactionignore-and-dtactionname).
+### Monitor a Component
 
-## New RUM experience
+A component can be either monitored automatically or manually. The auto instrumentation is handled via the dynatrace.config.js file. If you want to manually instrument a component you can use the API call `withMonitoring`.
 
-The New RUM Experience introduces a set of advanced APIs that allow you to send custom events, modify event data, track exceptions, monitor HTTP requests, and manage view contexts in your React Native application. These APIs provide more granular control over the data captured by Dynatrace and are designed for the next generation RUM capabilities.
+* Example with Functional Component:
 
-For more detailed information about the New RUM Experience, see the [official Dynatrace documentation](https://docs.dynatrace.com/docs/shortlink/react-native-main).
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
+import { FunctionComponent } from 'react';
 
-### Send Event
+export const MyFunctionalComponent: FunctionComponent<{}> = () => {
+  return null;
+}
 
-The `sendEvent()` method allows you to send custom events with arbitrary properties using the EventData class. This is useful for tracking specific user interactions or application state changes.
+Dynatrace.withMonitoring(MyFunctionalComponent, "MyFunctionalComponent");
+```
+![rnFunctionalComp](https://dt-cdn.net/images/rnfunctionalcomp-800-d98eacef6d.png)
 
-```ts
-import { Dynatrace, EventData } from '@dynatrace/react-native-plugin';
+The String "MyFunctionalComponent" is optional as the name of the component can be retrieved through [different properties](#how-does-dynatrace-determine-the-user-action-name).
 
-// Send a custom event with properties
-Dynatrace.sendEvent(new EventData()
-  .addEventProperty("event_properties.button_clicked", "login_button")
-  .addEventProperty("event_properties.user_type", "premium")
-  .addEventProperty("event_properties.attempt_count", 3)
-  .withDuration(250)
-);
-```
+Combining manual and auto instrumentation should not be a problem. As they're running the same execution, the manual instrumentation will only override the content of auto instrumentation happening through the transformer.
 
-**Property Requirements:**
-* Only properties prefixed with `event_properties.*` are allowed
-* Additionally, the `duration` property is allowed
-* Maximum of 50 custom properties per event
-  * If the limit is exceeded, properties are sorted alphabetically by key and excess properties are dropped deterministically
-* String properties are limited to 5000 characters (exceeding characters are truncated)
-* Field names must contain only alphabetic characters, numbers, underscores, and dots
-* Each dot must be followed by an alphabetic character
-* Each underscore must be followed by an alphabetic character or number
-* Values must be primitive types (string, number, boolean)
-* Cannot contain functions, undefined, Infinity, or NaN as values (they will be replaced with null)
+### Create custom actions
 
-### Send Session Property Event
+There are two options to create an action. Either using `enterAutoAction` (the previous `enterAction`) or `enterManualAction`:
 
-Session properties apply to all events within the current session. Use `sendSessionPropertyEvent()` to set properties that should be available across the entire user session.
+**Important:** Action names are limited to 250 characters and will be truncated if they exceed this limit.
+
+* `enterAutoAction` - Creates an Action which will be automatically handled by the plugin (This is the type of action which is internally used by the plugin when monitoring components and touchables). This means that the plugin decides about the hierarchy of this action. If there is no open action, the following action will be a root action. All other actions created by this method, while a root action is open, will be automatically inserted as a child action. Furthermore the plugin will automatically link webrequest (if they are not tagged manually) to the open root action. Be aware that the timeout/wait time for sub actions or web requests cannot be modified on the Android side for React Native Auto actions. The timeout is fixed to a 1000ms.
 
 ```ts
-import { Dynatrace, SessionPropertyEventData } from '@dynatrace/react-native-plugin';
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-// Set session-wide properties
-Dynatrace.sendSessionPropertyEvent(new SessionPropertyEventData()
-  .addSessionProperty("session_properties.user_tier", "premium")
-  .addSessionProperty("session_properties.app_version", "2.1.0")
-  .addSessionProperty("session_properties.feature_flag_enabled", true)
-);
+const myAction = Dynatrace.enterAutoAction("MyButton tapped");
+//Perform the action and whatever else is needed.
+myAction.leaveAction();
 ```
+![rnSingle](https://dt-cdn.net/images/rnsingle-800-e7e1b343ed.png)
 
-**Important Notes:**
-* Session properties persist throughout the entire session
-* If you send the same property multiple times, only one value will be kept (first or last)
-* Use session properties for data that applies to the entire user session
-* Field naming follows the same rules as events, but with `session_properties.` prefix
-* Maximum of 50 custom properties per event
-  * If the limit is exceeded, properties are sorted alphabetically by key and excess properties are dropped deterministically
+* `enterManualAction` - Creates an Action which will NOT be handled by the plugin. This means that you have full control about the hierarchy of your actions. This function will create a root action for you, which has the ability to create child actions via `enterAction`. Be aware, because of the full manual approach the plugin will not link webrequest automatically. Webrequest have to be manually tagged by using the tag provided by the action via `getRequestTag`.
 
-### Event Modifier
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-Event modifiers allow you to intercept and modify events before they are sent to Dynatrace. This is useful for adding common properties, filtering sensitive data, or enriching events with additional context. Event modifiers apply to all event types, including custom events, session properties, exceptions, and HTTP events.
+const myAction = Dynatrace.enterManualAction("MyButton tapped");
+//Perform the action and whatever else is needed.
+myAction.leaveAction();
+```
 
-If multiple event modifiers are added, they are executed in the order they were added.
+To create a custom action named `"MyButton tapped"`, use the following code. The *leaveAction* closes the action again. To report values for this action before closing, see [Report Values](#report-values).
 
-Most fields and namespaces can't be modified in any way (added, removed or overridden), while others are open for modification.
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-**Open for modification and can be added:**
-- `event_properties.*`
-- `session_properties.*`
+const myAction = Dynatrace.enterAutoAction("MyButton tapped");
+//Perform the action and whatever else is needed.
+myAction.leaveAction();
+```
 
-`session_properties.*` are only allowed to be on a session property event.
+### Create custom sub actions
 
-**Open for modification only:**
-- `url.full`
-- `exception.stack_trace`
+You can create a single custom action as well as sub actions. The `MyButton Sub Action` is automatically put under the `MyButton tapped`. As long as `MyButton tapped` is open, it gathers all the web requests.
 
-#### Example
+**Important:** Action names are limited to 250 characters and will be truncated if they exceed this limit.
 
 ```ts
-import { Dynatrace, IEventModifier } from '@dynatrace/react-native-plugin';
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-// Create an event modifier
-const myModifier: IEventModifier = {
-  modifyEvent(event) {
-    // Add common properties to all events
-    event["event_properties.app_build"] = "1.2.3";
-    event["event_properties.environment"] = "production";
-    
-    // Return null to discard the event entirely
-    if (event["event_properties.ignore"] === true) {
-      return null;
-    }
-    
-    return event;
-  }
-};
+const myAction = Dynatrace.enterManualAction("MyButton tapped");
+const mySubAction = myAction.enterAction("MyButton Sub Action");
+//Perform the action and whatever else is needed.
+mySubAction.leaveAction();
+myAction.leaveAction();
+```
+![subAction](https://dt-cdn.net/images/subaction-800-172dbcca6c.png)
 
-// Add the modifier
-Dynatrace.addEventModifier(myModifier);
+### Cancel actions
 
-// Remove the modifier when no longer needed
-Dynatrace.removeEventModifier(myModifier);
-```
+Actions can be canceled. That means they will not be sent and discarded fully. This also means that any values and sub actions attached to the action will be removed. 
 
-#### Important Considerations
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-- **Execution order**: If multiple event modifiers are added, they are executed in the order they were added
-- **Returning null**: Returning `null` discards the event and prevents future modifier functions from being executed
-- **Performance**: Event modifiers should be efficient as they are called for every event
-- **Field naming**: Custom properties must follow the `event_properties.*` or `session_properties.*` prefix naming convention
-- **Reserved fields**: Certain reserved fields and namespaces cannot be modified. Attempts to modify them will be ignored
-- **Error handling**: If a modifier throws an exception, it will be logged but won't prevent other modifiers from executing
-- **Primitive values**: Event fields can only contain primitive values (String, int, double, bool)
-- **Invalid argument**: In case you pass an invalid argument to `addEventModifier`, we return a no-op placeholder modifier.
+const myAction = Dynatrace.enterAutoAction("MyButton tapped");
+// Action will be canceled
+myAction.cancel();
 
-### Send Exception Event
+// Has no impact as the action is already canceled
+myAction.leaveAction();
+```
 
-The `sendExceptionEvent()` method provides a structured way to report exceptions with additional context and custom properties using the ExceptionEventData class.
+### Manual Web Request Tagging
+
+You can manually tag and time your web requests. With the API shown below, you are able to manually capture the web requests of an http framework/library. 
+
+**Note:** 
+Using this API will force the request to be added to the action that is manually created. 
 
 ```ts
-import { Dynatrace, ExceptionEventData } from '@dynatrace/react-native-plugin';
+import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin';
+
+const action = Dynatrace.enterManualAction('API Data Fetch');
+const url = 'https://api.example.com/data';
+const tag = await action.getRequestTag(url);
+const timing = new DynatraceWebRequestTiming(tag, url);
 
 try {
-  // Code that may throw an error
-  throw new Error('Something went wrong');
+  timing.startWebRequestTiming();
+  const response = await fetch(url, {
+    headers: {
+      [timing.getRequestTagHeader()]: tag
+    }
+  });
+  timing.stopWebRequestTiming(response.status, response.statusText);
 } catch (error) {
   if (error instanceof Error) {
-    Dynatrace.sendExceptionEvent(new ExceptionEventData(error)
-      .addEventProperty('event_properties.custom_key', 'custom_value')
-      .addEventProperty('event_properties.error_context', 'user_action')
-    );
+    timing.stopWebRequestTiming(-1, error.message);
+  } else {
+    timing.stopWebRequestTiming(-1, (error as any).toString());
   }
+} finally {
+  action.leaveAction();
 }
 ```
+![rnManualWeb](https://dt-cdn.net/images/rnmanualweb-800-662d009613.png)
 
-**Parameters:**
-* `error`: The Error object containing exception information (required)
+There is also the option to report values for request and response size:
 
-### Send HTTP Request Event
+```ts
+import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin';
 
-The `sendHttpRequestEvent()` method allows you to manually report HTTP request events with detailed information about the request and response.
+const action = Dynatrace.enterManualAction('API Data Upload');
+const url = 'https://api.example.com/upload';
+const tag = await action.getRequestTag(url);
+const timing = new DynatraceWebRequestTiming(tag, url);
+const requestData = JSON.stringify({ key: 'value' });
 
-```ts
-import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
+try {
+  timing.startWebRequestTiming();
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      [timing.getRequestTagHeader()]: tag,
+      'Content-Type': 'application/json'
+    },
+    body: requestData
+  });
+  const responseData = await response.text();
+  timing.stopWebRequestTimingWithSize(
+    response.status,
+    response.statusText,
+    requestData.length,
+    responseData.length
+  );
+} catch (error) {
+  if (error instanceof Error) {
+    timing.stopWebRequestTiming(-1, error.message);
+  } else {
+    timing.stopWebRequestTiming(-1, (error as any).toString());
+  }
+} finally {
+  action.leaveAction();
+}
+```
+![rnBytes](https://dt-cdn.net/images/rnbytes-800-139042060c.png)
 
-// Basic HTTP request event
-const requestEventData = new HttpRequestEventData('https://api.example.com/users', 'GET');
-Dynatrace.sendHttpRequestEvent(requestEventData);
+### Report values
 
-// HTTP request with additional details
-const detailedRequestEventData = new HttpRequestEventData('https://api.example.com/data', 'POST')
-  .withStatusCode(200)
-  .addEventProperty('event_properties.headers.content_type', 'application/json');
-Dynatrace.sendHttpRequestEvent(detailedRequestEventData);
+For any open action you can report certain values. The following API is available for action:
+
+```ts
+import { Platform } from '@dynatrace/react-native-plugin';
+
+interface IDynatraceAction {
+  reportDoubleValue(valueName: string, value: number, platform?: Platform): void;
+  reportError(errorName: string, errorCode: number, platform?: Platform): void;
+  reportEvent(eventName: string, platform?: Platform): void;
+  reportIntValue(valueName: string, value: number, platform?: Platform): void;
+  reportStringValue(valueName: string, value: string, platform?: Platform): void;
+}
 ```
 
-**Parameters:**
-* `url`: The URL of the HTTP request (required)
-* `method`: The HTTP method (e.g., 'GET', 'POST', 'PUT', 'DELETE') (required)
+**Important:** All string parameters (errorName, eventName, valueName, value) are limited to 250 characters and will be truncated if they exceed this limit.
 
-### View Monitoring
+To report a string value, use the following:
 
-The view monitoring APIs allow you to track different screens or views in your application, providing context for all events happening within those views.
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-There are two ways to monitor views:
-1. **Automatic view monitoring** - Enable navigation tracking in your configuration to automatically capture view changes through supported navigation libraries (enabled by default)
-2. **Manual view monitoring** - Use the `startView()` API to manually control when view contexts are created and updated
+const myAction = Dynatrace.enterAutoAction("MyButton tapped");
+myAction.reportStringValue("ValueName", "ImportantValue");
+myAction.leaveAction();
+```
+![rnReportString](https://dt-cdn.net/images/rnreportstring-800-739e5ba752.png)
 
-> **Important:** These approaches should not be mixed, as the outcome is unpredictable. Choose either automatic or manual view monitoring for your application.
+If you look at the API calls, you will see the optional parameter `platform?: Platform`. This parameter offers the possibility to report values only for a specific platform. to know more, see [Platform independent reporting](#platform-independent-reporting).
 
-#### Automatic Navigation tracking
 
-> **Note:** This feature only works with `@react-navigation` versions 5.x through 7.x.
+### Report an error stacktrace
 
-The following is an example of how this feature can be configured in your `dynatrace.config.js` file. Note that this feature is enabled by default.
+To manually report an error stacktrace, use the following API call:
 
-```js
-react: {
-  navigation: {
-    enabled: true
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
+
+try {
+  throw new Error('Database connection failed');
+} catch (error) {
+  if (error instanceof Error) {
+    Dynatrace.reportErrorStacktrace(
+      'DatabaseError',
+      error.message,
+      'Failed to connect to remote database',
+      error.stack || 'No stack trace available'
+    );
   }
 }
 ```
+![rnStack](https://dt-cdn.net/images/rnstack-800-26c6ac7408.png)
 
-When this feature is enabled, the view context will represent the current state of the `@react-navigation` `NavigationContainer`. The state gets represented as a URL-style route. All subsequent events get associated with the view context and thus with the current route.
+**Note:**
+The previous API without *errorValue* is deprecated and will be removed in the future. Please use the new API with errorValue if possible.
 
-For instance, assume the following setup:
-```js
-const Drawer = createDrawerNavigator();
+### Manually report a crash
 
-function App() {
-  return (
-    <NavigationContainer>
-      <Drawer.Navigator initialRouteName="Home">
-        <Drawer.Screen name="Home" component={HomeScreen} />
-        <Drawer.Screen name="Feature" component={FeatureScreen}/>
-      </Drawer.Navigator>
-    </NavigationContainer>
-  );
-}
+You can manually report a crash via the following API calls:
 
-const Stack = createStackNavigator();
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-function FeatureScreen() {
-  return (
-    <Stack.Navigator initialRouteName="ScreenOne">
-      <Stack.Screen name="ScreenOne" component={NestedScreenOne} />
-      <Stack.Screen name="ScreenTwo" component={NestedScreenTwo} />
-    </Stack.Navigator>
-  );
+try {
+  throw new Error('Fatal memory allocation failure');
+} catch (error) {
+  if (error instanceof Error) {
+    Dynatrace.reportCrash(
+      'MemoryError',
+      error.message,
+      error.stack || 'No stack trace available'
+    );
+
+    // or directly via the full error
+    Dynatrace.reportCrashWithException('MemoryError', error);
+  }
 }
 ```
+![rnCrash](https://dt-cdn.net/images/rncrash-800-3e7391140f.png)
 
-When navigating to `Home`, the view context will be set to `/Home`. When navigating to `Feature` and being redirected to the nested `ScreenOne`, the view context will be set to `/Home/ScreenOne`.  When navigating to `ScreenTwo` within `Feature`, the view context will be set to `/Feature/ScreenTwo`.
+> **Note**: If you use this API call to report a crash manually, it will force the session to be completed. Any new actions that are captured afterwards will be added into a new session.
 
-#### Start View
+*reportCrashWithException* will use the crashName as name for the crash. It will only report the crash if there is also a stacktrace available. 
 
-Use `startView()` to begin monitoring a specific view or screen. When a view is started, all subsequent events will be associated with that view context.
+### Report GPS Location
+
+You can report latitude and longitude and specify an optional platform. 
 
 ```ts
 import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-// Start monitoring a view
-Dynatrace.startView("HomeScreen");
+Dynatrace.setGPSLocation(48.31518732698596, 14.305245274594471);
 ```
 
-**Important Considerations:**
-* Only one view can be active at a time
-* Starting a new view will automatically stop the previous one
-* View names should be meaningful and consistent across your application
-* All events captured after starting a view will include the view context
-
-**Complete Example:**
+### Platform independent reporting
 
+You probably noticed that each method has an additional *optional* parameter named `platform` of type `Platform`. You can use this to only trigger manual instrumentation for a specific OS. The available values are: `Platform.Ios` and `Platform.Android`. Default is that it will work on any platform. Otherwise it is passed *only* to the relevant OS. For example:
+ * Passing to **iOS** only:
 ```ts
-import { Dynatrace, EventData } from '@dynatrace/react-native-plugin';
+import { Dynatrace, Platform } from '@dynatrace/react-native-plugin';
 
-// User navigates to profile screen
-Dynatrace.startView("UserProfile");
+const myAction = Dynatrace.enterAutoAction("MyButton tapped", Platform.Ios);
+//Perform the action and whatever else is needed.
+myAction.leaveAction(Platform.Ios); 
+```
+ 
+ * Passing to **Android** only:
+```ts
+import { Dynatrace, Platform } from '@dynatrace/react-native-plugin';
 
-// Send custom event within the view
-Dynatrace.sendEvent(new EventData()
-  .addEventProperty("event_properties.profile_action", "edit_profile")
-  .addEventProperty("event_properties.changes_made", true)
-);
+const myAction = Dynatrace.enterAutoAction("MyButton tapped", Platform.Android);
+//Perform the action and whatever else is needed.
+myAction.leaveAction(Platform.Android); 
+```
+ 
+ * Passing to **both**:
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-// User navigates away
-Dynatrace.startView("UserProfileDetailed");
+const myAction = Dynatrace.enterAutoAction("MyButton tapped");
+//Perform the action and whatever else is needed.
+myAction.leaveAction(); 
 ```
 
-### User Interaction
+### Business event capturing
 
-User Interaction is an automatic instrumentation feature that captures touch and press events in your React Native application without requiring any manual API calls. When enabled, the plugin instruments your UI components at build time and sends structured interaction events to Dynatrace at runtime.
+With `sendBizEvent`, you can report business events. These events are standalone events, as OneAgent sends them detached from user actions or user sessions.
 
-The following is an example of how this feature can be configured in your `dynatrace.config.js` file. Note that this feature is enabled by default.
+For more information on business events, see [dynatrace documentation](https://docs.dynatrace.com/docs/observe/business-observability/explore-business-events).
 
-```js
-react: {
-  userInteraction: true
-}
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
+
+Dynatrace.sendBizEvent("com.easytravel.funnel.booking-finished", {
+  "event.name" : "Confirmed Booking",
+  "screen": "booking-confirmation",
+  "product": "Danube Anna Hotel",
+  "amount": 358.35,
+  "currency": "USD",
+  "reviewScore": 4.8,
+  "arrivalDate": "2022-11-05",
+  "departureDate": "2022-11-15",
+  "journeyDuration": 10,
+  "adultTravelers": 2,
+  "childrenTravelers": 0
+});
 ```
+![rnBiz](https://dt-cdn.net/images/rnbiz-1262-f57a0a67f3.png)
 
-When enabled, UI Interaction can be controlled by two layers:
+### Setting beacon headers
 
-1. **Build/config layer (`dynatrace.config.js`)**
-  - `react.userInteraction: true|false` controls whether the UI Interaction instrumentation feature is applied.
+This allows you to put a set of http headers on every agent http request (i.e. Authorization header etc.). It will also triggers the agent to reconnect to the beacon endpoint with the new headers. 
 
-2. **Runtime remote layer (`RuntimeConfigurationObserver`)**
-  - Runtime emission checks the remote flag `touch_interaction_enabled`.
-  - If remote flag is present, it is used as the source of truth.
-  - If remote flag is temporarily unavailable, the plugin falls back to the last known good remote value.
-  - If no remote value was received yet, runtime defaults to enabled behavior.
+**Note:** To clear the previously set headers, call the method without the headers parameter or with a null value for the headers parameter.
 
-#### Masking sensitive UI labels
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-UI Interaction also supports masking sensitive labels before events are sent.
+const beaconHeaders = new Map<string, string>();
+beaconHeaders.set('headerName', 'headerValue');
+Dynatrace.setBeaconHeaders(beaconHeaders);
+```
 
-Masking is applied when:
+### Exclude Individual JSX Elements
 
-* the touched element or one of its parents is marked with `dtMask`
-* the runtime masking rules classify the detected text as sensitive
-* the runtime masking rules classify the element `testID` as sensitive
+If you want to instrument a functional component or class component but want to exclude a certain button or element, you can do this via the `dtActionIgnore` property. Example:
 
-When masking is active:
+```tsx
+import React from 'react';
+import { TouchableHighlight, Text, View } from 'react-native';
 
-* the interaction path and component information are still reported
-* the detected UI label is replaced with the configured replacement string (default: `***`)
-* `ui_element.name_origin` is reported as `masked`
+const TouchableHighlightScreen = () => {
+    return (
+        <View>
+            <TouchableHighlight onPress={onPress}>
+                <Text>TouchableHighlight that will be monitored</Text>
+            </TouchableHighlight>
+            <TouchableHighlight onPress={onPress} dtActionIgnore="true">
+                <Text>TouchableHighlight that will be ignored</Text>
+            </TouchableHighlight>
+        </View>
+    );
+};
 
-Example using `dtMask`:
+const onPress = () => {
+    console.log("TouchableHighlight Pressed!");
+};
 
-```tsx
-<View dtMask>
-  <Pressable onPress={onPress}>
-    <Text>john.doe@example.com</Text>
-  </Pressable>
-</View>
+export default TouchableHighlightScreen;
 ```
 
-This allows you to preserve interaction analytics while avoiding exposure of sensitive text in the emitted UI Interaction event.
-
+This example shows two *TouchableHighlight*, which will fire the *onPress()* function when pressed. The property `dtActionIgnore="true"` will prevent the monitoring of one of them. This means that the onPress will still be executed but we will no longer create a user action which is wrapping the button click. 
 
-#### Produced data
+>*Attention:* If you are using Typescript and want to set this property with type-safety, look [here](#typescript-setup-for-dtactionignore-and-dtactionname).
 
-Each captured interaction produces an event describing what the user touched and where. The event includes:
+## Extended topics
 
-- **Detected name** — the resolved label of the touched element, derived from its visible text, accessibility label, component name, or test ID.
-- **Component** — the type of the UI component that was touched (e.g. `Pressable`).
-- **Component Path** — a stable path through the component tree that uniquely identifies the element (e.g. `App/View[1]/Pressable[1]`).
-- **Interaction type** — how the user interacted (e.g. `touch`).
-- **Position** — the screen coordinates where the touch occurred.
+### Identify a user
 
-In some cases, a **responder** is also included. The responder is the component that ultimately handled the user's touch — for example, a `Pressable` that received the press event. It carries the same name, component type, and path information as the touched element, and can differ when a touch is visually on a child element but handled by a parent.
+You can identify a user and tag the current session with a name by making the following call:
 
-If masking is active for an interaction, the event still contains the same structural information, but the detected name is replaced and the name origin changes to `masked`.
+**Important:** The user identifier is limited to 250 characters and will be truncated if it exceeds this limit.
 
-#### Example event
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-```json
-{
-  "characteristics.has_user_interaction": true,
-  "ui_element.detected_name": "LoginButton",
-  "ui_element.components": ["Pressable"],
-  "ui_element.id": "App/View/Pressable",
-  "ui_element.name_origin": "component",
-  "interaction.type": "touch",
-  "positions": [{ "x": 120, "y": 460 }],
-  "ui_element.responder.detected_name": "Pressable",
-  "ui_element.responder.components": ["Pressable"],
-  "ui_element.responder.id": "App/View[/Pressable",
-  "ui_element.responder.name_origin": "component"
-}
+Dynatrace.identifyUser("User XY");
 ```
+![rnTag](https://dt-cdn.net/images/rntag-800-77fe848023.png)
 
-#### Custom Names for Components
-
-You can assign custom names to your components. A custom name affects both the **Component** and the **Component Path** described above. There are two ways to do this, depending on how the component is used.
+### End the current user session
 
-##### 1. As a JSX prop (`dtActionName`)
+To end the current user session, use the following API call:
 
-Use this when you render the component as JSX. Pass `dtActionName` as a prop, and it overrides the auto-detected name for that specific usage:
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-```tsx
-<TouchableOpacity dtActionName="Checkout Button" onPress={onCheckout}>
-    <Text dtActionName="Checkout Text">Buy now</Text>
-</TouchableOpacity>
+Dynatrace.endSession();
 ```
 
-Touching it produces:
+**Note:** The user tagging will not carry over to the new user session that is started after using this API. If user tagging is desired in the new user session, please ensure that you call the [user tagging](#identify-a-user) API.
 
-```json
-"ui_element.components": ["Checkout Text"],
-"ui_element.id": ".../Checkout Button/Checkout Text"
-```
+### User Privacy Options
 
-##### 2. As a static property (`Component.dtActionName`)
+The privacy API methods allow you to dynamically change the data-collection level based on the individual preferences of your end users. Each end user can select from three data-privacy levels:
 
-Use this when the component is **not** rendered as JSX, so the prop approach above is not available — for example, a screen component you define once and hand to a navigator by reference. Set `dtActionName` directly on the component. This affects **every** place the component is used at once:
+```ts
+export enum DataCollectionLevel {
+    Off, Performance, UserBehavior
+}
+```
 
-```tsx
-import { NavigationContainer } from '@react-navigation/native';
-import { createDrawerNavigator } from '@react-navigation/drawer';
+1. Off: Native Agent doesn't capture any monitoring data.
+2. Performance: Native Agent captures only anonymous performance data. Monitoring data that can be used to identify individual users, such as user tags and custom values, aren't captured.
+3. UserBehavior: Native Agent captures both performance and user data. In this mode, Native Agent recognizes and reports users who re-visit in future sessions.
 
-const Drawer = createDrawerNavigator();
+Crash reporting is enabled by default. The Mobile agent captures all unhandled exceptions/errors and immediately sends the crash report to the server. With this API you can activate or deactivate crash reporting. To change this behaviour via the API, enable/activate [`userOptIn`](#user-opt-in-mode) and set the User Privacy Options.
 
-function ProfileScreen() {
-    return (/* ... */);
-}
+The API to get and set the current privacy level looks like this:
 
-// Applies to all usages of ProfileScreen below
-ProfileScreen.dtActionName = 'User Profile';
+```ts
+import { Platform, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
 
-function App() {
-    return (
-        <NavigationContainer>
-            <Drawer.Navigator>
-                {/* Both screens reference the same component,
-                    so both pick up the 'User Profile' name */}
-                <Drawer.Screen name="Me" component={ProfileScreen} />
-                <Drawer.Screen name="Account" component={ProfileScreen} />
-            </Drawer.Navigator>
-        </NavigationContainer>
-    );
+interface IDynatrace {
+  getUserPrivacyOptions(platform?: Platform): Promise<UserPrivacyOptions>;
+  applyUserPrivacyOptions(userPrivacyOptions: UserPrivacyOptions, platform?: Platform): void;
 }
 ```
 
-Touches inside one of the 2 screens now produce:
-
-```json
-"ui_element.id": ".../User Profile/..."
-```
-
-> **Note:** The static property applies to *all* uses of the component. If you need a different name per usage, render the component as JSX and use the `dtActionName` prop (option 1) instead.
->
-> **Note:** The static property has no effect when a component is rendered as JSX. In that case the name is taken from either the `dtActionName` prop passed to it (option 1) or the name of the JSX component.
-
-### React Native Symbolication
+To check the current privacy options that are set:
 
-Dynatrace can automatically symbolicate JavaScript stack traces captured by the plugin using sourcemaps. This allows you to view human-readable file names, line numbers, and column information in your crash reports.
+```ts
+import { Dynatrace } from '@dynatrace/react-native-plugin';
 
-#### Generating Sourcemaps
+const privacyOptions = await Dynatrace.getUserPrivacyOptions();
+```
 
-Sourcemaps are generated during release builds and map bytecode offsets (Hermes) and locations in the minified JavaScript bundle (JavaScriptCore) back to your original source code. We support sourcemaps for both Hermes and JavaScriptCore. For detailed instructions on generating sourcemaps, see the [React Native debugging release builds guide](https://reactnative.dev/docs/debugging-release-builds).
+If you want to create a new `UserPrivacyOptions` object and pass it to Dynatrace:
 
-To generate a sourcemap:
+```ts
+import { Dynatrace, DataCollectionLevel, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
 
-**Android:**
-* Run `npx react-native run-android --mode release` in your project root, or
-* Run `gradlew assembleRelease` in the `/android` directory
+const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.UserBehavior, true);
 
-**iOS:**
-* First, enable sourcemaps according to the [React Native debugging release builds guide](https://reactnative.dev/docs/debugging-release-builds)
-* Then run `npx react-native run-ios --mode Release`, or
-* Build for release in Xcode
+// Getter and setter available for UserPrivacyOptions
+privacyConfig.crashReportingOptedIn = false;
+privacyConfig.dataCollectionLevel = DataCollectionLevel.Performance;
 
-#### Uploading Sourcemaps
+const level = privacyConfig.dataCollectionLevel;
+const crashReporting = privacyConfig.crashReportingOptedIn;
 
-Once generated and patched, upload your sourcemaps to Dynatrace. For detailed instructions, see the [symbol file management documentation](https://docs.dynatrace.com/docs/observe/digital-experience/mobile-applications/analyze-and-use/upload-and-manage-symbol-files).
+Dynatrace.applyUserPrivacyOptions(privacyConfig);
+```
 
 ## NPX Commands
 
@@ -1149,7 +1158,6 @@ The following npx commands are available for the plugin:
 
 * npx instrumentDynatrace - Is triggering the configuration process and will insert the configuration into the Android and iOS application. This is mandatory and should usually happen automatically when doing `react-native run-android` or `react-native run-ios` command.
 * npx configDynatrace - Is checking the current configuration and is creating a default configuration if there is none.
-* npx lineOffsetDynatrace - ...
 
 ### npx instrumentDynatrace
 
@@ -1520,18 +1528,6 @@ The changes our auto-instrumentation is making now get dumped into the `node_mod
 
 > **Note:** This feature increases the time it takes to build the Javascript bundle. Only use it for debugging purposes. Deactivate it otherwise, especially when fast build times are important.
 
-#### Using our legacy jscodeshift auto-instrumentation
-
-We recently moved our auto-instrumentation to a babel plugin. In case you need to, you can still switch to the old jscodeshift auto-instrumentation with this flag:
-
-```js
-react: {
-  useLegacyJscodeshift: true
-}
-```
-
-> **Note:** When we moved our auto-instrumentation to a babel plugin, we removed documentation that was only relevant for the jscodeshift auto-instrumentation. Most notably, we removed documentation concerning registering a custom metro transformer and patching sourcemaps. If you use the `useLegacyJscodeshift` flag, please refer to the [legacy documentation (v2.333.1)](https://www.npmjs.com/package/@dynatrace/react-native-plugin/v/2.333.1) for details on custom metro transformers and sourcemap patching.
-
 ### Android block
 
 The Android block is a wrapper for the Android configuration you find in the WebUI (in the Mobile Application Settings). Copy the content into the following block:
@@ -1701,7 +1697,7 @@ ios: {
   * class name: If the display name is not available, the class name is used by taking the property name from the constructor
 * Touchables, Buttons, Pressable
   * dtActionName: Use a custom property called dtActionName
-  * If [actionNamePrivacy](#plugin-startup) is activated anything below will not be detected
+  * If [actionNamePrivacy](#manual-oneagent-startup) is activated anything below will not be detected
   * title property
   * accessibilityLabel property
   * If none of the above exist, we recursively traverse `children` to find a name. We consider text, the source property of any `ReactNative.Image` and the name property of any functional component called `Icon`.
@@ -1751,7 +1747,7 @@ import { Text } from 'react-native';
 </TouchableHighlight>
 ```
 
-*Note:* [actionNamePrivacy](#plugin-startup) has no impact on using dtActionName. dtActionName will always be used.
+*Note:* [actionNamePrivacy](#manual-oneagent-startup) has no impact on using dtActionName. dtActionName will always be used.
 
 >*Attention:* If you are using Typescript and want to set this property with type-safety, look [here](#typescript-setup-for-dtactionignore-and-dtactionname).
 
@@ -1765,7 +1761,7 @@ In general, Dynatrace always closes the session when a crash occurs. Usually a c
 * Fatal error: If the error is considered as fatal by the React Native crash handler, it will be treated as crash.
 * Native crashes: If a crash appears solely on the native side and is not noticed by the internal React Native crash handler, it will be reported directly by the Android or iOS agent.
   * Exception: Some JavaScript crashes will result in Native crashes. Therefore, they are filtered on the native side as normally the crash would be reported twice. On the JavaScript side, these crashes are already reported by us before they hit the native side resulting in no lost information.
-Additionally, you can use our crash and error reporting APIs which are available with [manual instrumentation](#manual-instrumentation).
+Additionally, you can use our crash and error reporting APIs which are available with [RUM Classic](#rum-classic).
 
 
 ## React Automatic Runtime
@@ -2088,6 +2084,27 @@ If you are struggling with a problem, submit a support ticket to Dynatrace (supp
 <br/><br/>
 ## Changelog
 
+In Progress
+
+2.347.1
+* Updated Android (8.347.1.1003) & iOS Agent (8.347.1.1004)
+* Renamed `registerEventTrigger` to `registerNavigationEventTrigger` for clarity
+* Fixed re-configure failure to properly clear the table reload trigger
+* Updated `xmldom` dependency in Session Replay to a non-vulnerable version (DEM-32539)
+
+
+2.345.1
+* Updated Android (8.345.1.1003) & iOS Agent (8.345.1.1003)
+* Renamed `monitorNavigation` to `useNavigationMonitor`; React Navigation screen changes are now detected automatically, stamped with `start_time` and `duration`, and trigger Session Replay capture after the incoming screen settles
+* Added React Navigation support: settle detection on both Android and iOS bridges, UI-change capture toggling restored
+* Removed the bridge-side settle helper — the native agent now owns coalescing on both platforms
+* Added a runtime deprecation warning system
+* Removed the option to use the legacy jscodeshift auto-instrumentation by removing the `useLegacyJscodeshift` flag from `dynatrace.config.js`
+* Removed leading slash from reported view names
+* Discard user interaction actions when 3rd-gen instrumentation is disabled, even without an `onPress` callback
+* Android: compatibility fixes for AGP 9 and Kotlin 2.2 (React Native 0.87)
+* iOS: app-start measurement fixes for the new architecture
+
 2.343.1
 * Updated Android (8.343.1.1038) & iOS Agent (8.343.1.1007)
 * Added User Actions feature
@@ -2101,6 +2118,7 @@ If you are struggling with a problem, submit a support ticket to Dynatrace (supp
 * Added `DYNATRACE_CONFIG` environment variable as an alternative way to specify the config file path for the Metro/Babel transformer.
 * Added `npx instrumentDynatrace --reset` flag to clear a previously-persisted custom config path and revert the Metro/Babel transformer to the default `dynatrace.config.js` lookup. Useful after switching between build flavors that each use a different config file.
 * Fixed incorrect `start_time` on Android app start events when `3rd_gen_enabled` is false. The `EventPipeline` was suppressing the `forwardAppStartEvent` timing-correction call along with all other 3rd-gen events, causing the native Dynatrace SDK to report its own stale process-creation timestamp instead of the actual JS bundle load time.
+* CP now always forwards User Interaction Actions (UIA) to the native agent unconditionally, regardless of the `touch_interaction_enabled` server configuration flag. The native agent is responsible for deciding whether to record or discard each UIA. This applies to both the Babel-instrumented (`AnalyticsRoot`/`TouchCapture`) and the legacy JSX-wrapped Touchables UIA paths.
 
 2.341.1
 * Updated Android (8.341.1.1004) & iOS Agent (8.341.1.1010)
@@ -2128,7 +2146,7 @@ If you are struggling with a problem, submit a support ticket to Dynatrace (supp
 * Updated Android (8.337.2.1010) & iOS Agent (8.337.1.1003)
 * Fixed gradle path derivation for custom `--gradle` arguments: the plugin now correctly probes the filesystem to auto-detect `app/build.gradle(.kts)` with proper Kotlin DSL support, and validates that only `build.gradle` or `build.gradle.kts` files are accepted (not `settings.gradle`).
 * Enables [pnpm monorepo instrumentation](#pnpm-monorexpo-setup) by allowing explicit `config=`, `gradle=`, and `plist=` arguments in root `package.json` scripts, supporting shared native project layouts where `android/` and `ios/` are not co-located with each app.
-* Added [actionNamePreference](#plugin-startup) and [actionNameAlgorithm](#plugin-startup) configuration flags.
+* Added [actionNamePreference](#manual-oneagent-startup) and [actionNameAlgorithm](#manual-oneagent-startup) configuration flags.
 
 2.335.1
 * Updated Android (8.335.1.1001) & iOS Agent (8.335.1.1009)
@@ -2152,12 +2170,12 @@ If you are struggling with a problem, submit a support ticket to Dynatrace (supp
 
 2.329.1
 * Updated Android (8.329.1.1014) & iOS Agent (8.329.1.1017)
-* [New RUM experience](#new-rum-experience) Removed Dynatrace.stopView() API
-* [New RUM experience](#new-rum-experience) Enforcing length limitation of 5000 characters for user input values
-* [New RUM experience](#new-rum-experience) React Native Deobfuscation service via sourcemaps
+* [New RUM experience](#real-user-monitoring-rum) Removed Dynatrace.stopView() API
+* [New RUM experience](#real-user-monitoring-rum) Enforcing length limitation of 5000 characters for user input values
+* [New RUM experience](#real-user-monitoring-rum) React Native Deobfuscation service via sourcemaps
 * Adding [`npx lineOffsetDynatrace`](#npx-lineoffsetdynatrace) command
-* [New RUM experience](#new-rum-experience) Added automated view tracking via [navigation](#automatic-navigation-tracking)
-* [New RUM experience](#new-rum-experience) Event and session properties are now sorted alphabetically when the limit of 50 is exceeded, ensuring deterministic property dropping
+* [New RUM experience](#real-user-monitoring-rum) Added automated view tracking via [navigation](#automatic-navigation-tracking)
+* [New RUM experience](#real-user-monitoring-rum) Event and session properties are now sorted alphabetically when the limit of 50 is exceeded, ensuring deterministic property dropping
 
 2.327.2
 * Fixed iOS startup time calculation issues for React Native 0.72 and lower
@@ -2166,7 +2184,7 @@ If you are struggling with a problem, submit a support ticket to Dynatrace (supp
 
 2.327.1
 * Added [Compose Compatibility Note](#compose-compatibility-note)
-* Added [New RUM experience preview](#new-rum-experience) documentation
+* Added [New RUM experience preview](#real-user-monitoring-rum) documentation
 * Fixed iOS crash reporting by delaying the crash by 200ms on iOS to give the Agent enough time to report it
 * Updated Android (8.327.2.1004) & iOS Agent (8.327.1.1020)
 
@@ -2175,8 +2193,8 @@ If you are struggling with a problem, submit a support ticket to Dynatrace (supp
 
 2.325.1
 * Updated Android (8.325.1.1007) & iOS Agent (8.325.1.1012)
-* [New RUM experience preview](#new-rum-experience) ReactNative version now added to RUM on Grail event base data
-* [New RUM experience preview](#new-rum-experience) Added API documentation for RUM on Grail API
+* [New RUM experience preview](#real-user-monitoring-rum) ReactNative version now added to RUM on Grail event base data
+* [New RUM experience preview](#real-user-monitoring-rum) Added API documentation for RUM on Grail API
 
 2.323.2
 * Fixed error "Execution failed for task ':app:mergeReleaseAssets'. A problem occured starting process 'command 'npx''" when building for release on Windows.
@@ -2362,7 +2380,7 @@ If you are struggling with a problem, submit a support ticket to Dynatrace (supp
 2.247.1
 * Updated Android Agent (8.247.1.1003) & iOS Agent (8.247.1.1007)
 * Minimum supported Android SDK version raised to 21
-* Added [actionNamePrivacy](#plugin-startup) configuration flag
+* Added [actionNamePrivacy](#manual-oneagent-startup) configuration flag
 * Removed `instrumentDynatrace` from package.json
 * Adding [`npx instrumentDynatrace`](#npx-instrumentdynatrace) and [`npx configDynatrace`](#npx-configdynatrace) command