@dynatrace/react-native-plugin 2.327.2 → 2.329.1

package/README.md

@@ -16,7 +16,6 @@ If you want to start using this plugin and are not a Dynatrace customer yet, hea
 * Manual instrumentation
   * Typescript bindings to add manual instrumentation
 * New React-Native architecture
->**Note:** With iOS specifically, we noticed that there are some features that are not working the same as when using the current default architecture. You may experience issues with crash reporting being captured and web requests being linked to specific user actions. Per react native, [the new architecture is experimental](https://reactnative.dev/docs/the-new-architecture/landing-page#should-i-use-the-new-architecture-today). We will keep an eye on new updates and will continue to improve our support for the new architecture on both platforms.
 
 ## Requirements
 * React v16.8 or newer
@@ -34,8 +33,8 @@ If you want to start using this plugin and are not a Dynatrace customer yet, hea
 ## Agent Versions
 This agent versions are configured in this plugin:
 
-* Android Agent: 8.327.3.1006
-* iOS Agent: 8.327.2.1022
+* Android Agent: 8.329.1.1014
+* iOS Agent: 8.329.1.1017
 
 ## Quick Setup
 
@@ -64,21 +63,34 @@ This agent versions are configured in this plugin:
   * [Platform independent reporting](#platform-independent-reporting)
   * [Set beacon headers](#setting-beacon-headers)
   * [Exclude Individual JSX Elements](#exclude-individual-jsx-elements)
-* [New RUM experience preview](#new-rum-experience-preview)
+* [New RUM experience](#new-rum-experience)
   * [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)
 * [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)
 * [Configuration structure](#structure-of-the-dynatracejs-file)
   * [Manual Startup Counterparts](#manual-startup-counterparts)
+  * [React block](#react-block)
+    * [Input](#input)
+    * [Lifecycle](#lifecycle)
+    * [Debug mode](#debug-mode)
+    * [Error Handler](#error-handler)
+    * [Autostart](#autostart)
+    * [Bundle Name and Version](#bundle-name-and-version)
+    * [Navigation](#navigation)
+    * [Source Map](#source-map)
+  * [Android block](#android-block)
+  * [iOS block](#ios-block)
   * [Lifecycle modes](#lifecycle)
   * [Define build stages](#define-build-stages-in-dynatraceconfigjs)
   * [User Opt In Mode](#user-opt-in-mode)
@@ -224,11 +236,11 @@ A manual startup requires the following two steps:
 
 1. Deactivate the automated startup in `dynatrace.config.js`: 
 
-```js
+```ts
 module.exports = {
     react: {
         autoStart: false,
-        ...
+        // ...
     },
     android: {
         config: `
@@ -246,8 +258,8 @@ module.exports = {
         <key>DTXAutoStart</key>
         <false/>
         `
-    }
-}
+    },
+};
 ```
 
 2. Make the start-up call with at least `beaconUrl` and `applicationId`:
@@ -287,8 +299,7 @@ configurationBuilder.withCrashReporting(true)
   .withLogLevel(LogLevel.Info)
   .withLifecycleUpdate(false)
   .withUserOptIn(false)
-  .withActionNamePrivacy(false)
-  .withBundleName(undefined);
+  .withActionNamePrivacy(false);
   
 await Dynatrace.start(configurationBuilder.buildConfiguration());
 ```
@@ -320,9 +331,10 @@ A component can be either monitored automatically or manually. The auto instrume
 
 ```ts
 import { Dynatrace } from '@dynatrace/react-native-plugin';
+import { FunctionComponent } from 'react';
 
-export function MyFunctionalComponent(){
-  ...
+export const MyFunctionalComponent: FunctionComponent<{}> = () => {
+  return null;
 }
 
 Dynatrace.withMonitoring(MyFunctionalComponent, "MyFunctionalComponent");
@@ -412,22 +424,25 @@ Using this API will force the request to be added to the action that is manually
 ```ts
 import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin';
 
-let url = 'https://www.dynatrace.com';
-// You can also use enterAutoAction if desired
-let action = Dynatrace.enterManualAction("Manual Web Request");
-let tag = await action.getRequestTag(url);
-let timing = new DynatraceWebRequestTiming(tag, url);
+const action = Dynatrace.enterManualAction('API Data Fetch');
+const url = 'https://api.example.com/data';
+const tag = await action.getRequestTag(url);
+const timing = new DynatraceWebRequestTiming(url, tag);
 
-try {      
+try {
   timing.startWebRequestTiming();
-  let axiosResponse = await axios.get(url, {
+  const response = await fetch(url, {
     headers: {
-        timing.getRequestTagHeader(): tag
+      [timing.getRequestTagHeader()]: tag
     }
   });
-  timing.stopWebRequestTiming(axiosResponse.status, axiosResponse.data);
+  timing.stopWebRequestTiming(response.status, response.statusText);
 } catch (error) {
-  timing.stopWebRequestTiming(-1, error);
+  if (error instanceof Error) {
+    timing.stopWebRequestTiming(-1, error.message);
+  } else {
+    timing.stopWebRequestTiming(-1, (error as any).toString());
+  }
 } finally {
   action.leaveAction();
 }
@@ -439,22 +454,35 @@ There is also the option to report values for request and response size:
 ```ts
 import { Dynatrace, DynatraceWebRequestTiming } from '@dynatrace/react-native-plugin';
 
-let url = 'https://www.dynatrace.com';
-// You can also use enterAutoAction if desired
-let action = Dynatrace.enterManualAction("Manual Web Request");
-let tag = await action.getRequestTag(url);
-let timing = new DynatraceWebRequestTiming(url, tag);
+const action = Dynatrace.enterManualAction('API Data Upload');
+const url = 'https://api.example.com/upload';
+const tag = await action.getRequestTag(url);
+const timing = new DynatraceWebRequestTiming(url, tag);
+const requestData = JSON.stringify({ key: 'value' });
 
-try {      
+try {
   timing.startWebRequestTiming();
-  let axiosResponse = await axios.get(url, {
+  const response = await fetch(url, {
+    method: 'POST',
     headers: {
-        timing.getRequestTagHeader(): tag
-    }
+      [timing.getRequestTagHeader()]: tag,
+      'Content-Type': 'application/json'
+    },
+    body: requestData
   });
-  timing.stopWebRequestTimingWithSize(axiosResponse.status, axiosResponse.data, 122, 63);
+  const responseData = await response.text();
+  timing.stopWebRequestTimingWithSize(
+    response.status,
+    response.statusText,
+    requestData.length,
+    responseData.length
+  );
 } catch (error) {
-  timing.stopWebRequestTiming(-1, error);
+  if (error instanceof Error) {
+    timing.stopWebRequestTiming(-1, error.message);
+  } else {
+    timing.stopWebRequestTiming(-1, (error as any).toString());
+  }
 } finally {
   action.leaveAction();
 }
@@ -466,11 +494,15 @@ try {
 For any open action you can report certain values. The following API is available for action:
 
 ```ts
-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
+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;
+}
 ```
 
 **Important:** All string parameters (errorName, eventName, valueName, value) are limited to 250 characters and will be truncated if they exceed this limit.
@@ -494,7 +526,20 @@ If you look at the API calls, you will see the optional parameter `platform?: Pl
 To manually report an error stacktrace, use the following API call:
 
 ```ts
-reportErrorStacktrace(errorName: string, errorValue: string, reason: string, stacktrace: string, platform?: Platform): void;
+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)
 
@@ -528,11 +573,25 @@ Dynatrace.endSession();
 
 ### Manually report a crash
 
-You can manually report a crash via the following API call:
+You can manually report a crash via the following API calls:
 
 ```ts
-reportCrash(crashName: string, reason: string, stacktrace: string, platform?: Platform): void;
-reportCrashWithException(crashName: string, crash: Error, platform?: Platform): void;
+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'
+    );
+
+    // or directly via the full error
+    Dynatrace.reportCrashWithException('MemoryError', error);
+  }
+}
 ```
 ![rnCrash](https://dt-cdn.net/images/rncrash-800-3e7391140f.png)
 
@@ -559,8 +618,12 @@ Crash reporting is enabled by default. The Mobile agent captures all unhandled e
 The API to get and set the current privacy level looks like this:
 
 ```ts
-async getUserPrivacyOptions(platform?: Platform): Promise<UserPrivacyOptions>;
-applyUserPrivacyOptions(userPrivacyOptions: UserPrivacyOptions, platform?: Platform): void;
+import { Platform, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
+
+interface IDynatrace {
+  getUserPrivacyOptions(platform?: Platform): Promise<UserPrivacyOptions>;
+  applyUserPrivacyOptions(userPrivacyOptions: UserPrivacyOptions, platform?: Platform): void;
+}
 ```
 
 To check the current privacy options that are set:
@@ -571,32 +634,19 @@ import { Dynatrace } from '@dynatrace/react-native-plugin';
 const privacyOptions = await Dynatrace.getUserPrivacyOptions();
 ```
 
-If you want to create a new `UserPrivacyOptions` object:
+If you want to create a new `UserPrivacyOptions` object and pass it to Dynatrace:
 
 ```ts
-import { DataCollectionLevel, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
-
-let privacyConfig = new UserPrivacyOptions(DataCollectionLevel.UserBehavior, true);
-```
+import { Dynatrace, DataCollectionLevel, UserPrivacyOptions } from '@dynatrace/react-native-plugin';
 
-To set new values to this object:
+const privacyConfig = new UserPrivacyOptions(DataCollectionLevel.UserBehavior, true);
 
-```ts
+// Getter and setter available for UserPrivacyOptions
 privacyConfig.crashReportingOptedIn = false;
 privacyConfig.dataCollectionLevel = DataCollectionLevel.Performance;
-```
-
-The properties that are used to set the privacy options can also be used to fetch the options:
 
-```ts
-let level = privacyConfig.dataCollectionLevel;
-let crashReporting = privacyConfig.crashReportingOptedIn;
-```
-
-To apply the values that were set on the object:
-
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+const level = privacyConfig.dataCollectionLevel;
+const crashReporting = privacyConfig.crashReportingOptedIn;
 
 Dynatrace.applyUserPrivacyOptions(privacyConfig);
 ```
@@ -606,7 +656,9 @@ Dynatrace.applyUserPrivacyOptions(privacyConfig);
 You can report latitude and longitude and specify an optional platform. 
 
 ```ts
-setGPSLocation(latitude: number, longitude: number, platform?: Platform): void
+import { Dynatrace } from '@dynatrace/react-native-plugin';
+
+Dynatrace.setGPSLocation(48.31518732698596, 14.305245274594471);
 ```
 
 ### Platform independent reporting
@@ -618,7 +670,7 @@ import { Dynatrace, Platform } from '@dynatrace/react-native-plugin';
 
 const myAction = Dynatrace.enterAutoAction("MyButton tapped", Platform.Ios);
 //Perform the action and whatever else is needed.
-myAction.leaveAction("ios"); 
+myAction.leaveAction(Platform.Ios); 
 ```
  
  * Passing to **Android** only:
@@ -627,7 +679,7 @@ import { Dynatrace, Platform } from '@dynatrace/react-native-plugin';
 
 const myAction = Dynatrace.enterAutoAction("MyButton tapped", Platform.Android);
 //Perform the action and whatever else is needed.
-myAction.leaveAction("android"); 
+myAction.leaveAction(Platform.Android); 
 ```
  
  * Passing to **both**:
@@ -671,15 +723,22 @@ This allows you to put a set of http headers on every agent http request (i.e. A
 **Note:** To clear the previously set headers, call the method without the headers parameter or with a null value for the headers parameter.
 
 ```ts
-setBeaconHeaders(headers?: Map<string, string> | null, platform?: Platform): void;
+import { Dynatrace } from '@dynatrace/react-native-plugin';
+
+const beaconHeaders = new Map<string, string>();
+beaconHeaders.set('headerName', 'headerValue');
+Dynatrace.setBeaconHeaders(beaconHeaders);
 ```
 
 ### Exclude Individual JSX Elements
 
 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:
 
-```ts
-function TouchableHighlightScreen() {
+```tsx
+import React from 'react';
+import { TouchableHighlight, Text, View } from 'react-native';
+
+const TouchableHighlightScreen = () => {
     return (
         <View>
             <TouchableHighlight onPress={onPress}>
@@ -690,11 +749,11 @@ function TouchableHighlightScreen() {
             </TouchableHighlight>
         </View>
     );
-}
+};
 
-function onPress() {
-    Logger.logDebug("TouchableHighlight Pressed!");
-}
+const onPress = () => {
+    console.log("TouchableHighlight Pressed!");
+};
 
 export default TouchableHighlightScreen;
 ```
@@ -703,34 +762,33 @@ This example shows two *TouchableHighlight*, which will fire the *onPress()* fun
 
 >*Attention:* If you are using Typescript and want to set this property with type-safety, look [here](#typescript-setup-for-dtactionignore-and-dtactionname).
 
-## New RUM experience preview
-
-> **⚠️ Preview Feature**: The New RUM Experience APIs are currently in preview and may be subject to changes. These APIs provide enhanced event tracking capabilities with the new Dynatrace RUM on Grail feature.
+## New RUM experience
 
 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.
 
-For more detailed information about the New RUM Experience, see the [official Dynatrace documentation](https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api).
+For more detailed information about the New RUM Experience, see the [official Dynatrace documentation](https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/mobile-frontends).
 
 ### Send Event
 
-The `sendEvent()` method allows you to send custom events with arbitrary properties in JSON format. This is useful for tracking specific user interactions or application state changes.
+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.
 
 ```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+import { Dynatrace, EventData } from '@dynatrace/react-native-plugin';
 
 // Send a custom event with properties
-Dynatrace.sendEvent({
-  "event_properties.button_clicked": "login_button",
-  "event_properties.user_type": "premium",
-  "event_properties.attempt_count": 3,
-  "duration": 250
-});
+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)
+);
 ```
 
 **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
@@ -743,14 +801,14 @@ Dynatrace.sendEvent({
 Session properties apply to all events within the current session. Use `sendSessionPropertyEvent()` to set properties that should be available across the entire user session.
 
 ```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+import { Dynatrace, SessionPropertyEventData } from '@dynatrace/react-native-plugin';
 
 // Set session-wide properties
-Dynatrace.sendSessionPropertyEvent({
-  "session_properties.user_tier": "premium",
-  "session_properties.app_version": "2.1.0",
-  "session_properties.feature_flag_enabled": true
-});
+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)
+);
 ```
 
 **Important Notes:**
@@ -760,16 +818,33 @@ Dynatrace.sendSessionPropertyEvent({
 * Field naming follows the same rules as events, but with `session_properties.` prefix
 * 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
 
 ### Event Modifier
 
-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 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.
+
+If multiple event modifiers are added, they are executed in the order they were added.
+
+Most fields and namespaces can't be modified in any way (added, removed or overridden), while others are open for modification.
+
+**Open for modification and can be added:**
+- `event_properties.*`
+- `session_properties.*`
+
+`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';
 
 // Create an event modifier
-const myModifier = {
+const myModifier: IEventModifier = {
   modifyEvent(event) {
     // Add common properties to all events
     event["event_properties.app_build"] = "1.2.3";
@@ -791,57 +866,116 @@ Dynatrace.addEventModifier(myModifier);
 Dynatrace.removeEventModifier(myModifier);
 ```
 
-**Important Considerations:**
-* Modifiers are executed in the order they were added
-* Returning `null` from a modifier discards the event and prevents subsequent modifiers from executing
-* Certain reserved fields and namespaces cannot be modified (see [Dynatrace documentation](https://docs.dynatrace.com/docs/observe/digital-experience/new-rum-experience/api) for details)
-* Modifiers should be efficient as they are called for every event
+#### Important Considerations
+
+- **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)
 
 ### Send Exception Event
 
-The `sendExceptionEvent()` method provides a structured way to report exceptions with additional context and custom properties.
+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';
 
 try {
-  // Code that might throw an error
-  await riskyOperation();
+  // Code that may throw an error
+  throw new Error('Something went wrong');
 } catch (error) {
-  Dynatrace.sendExceptionEvent(error, {
-    "event_properties.operation_type": "data_sync",
-    "event_properties.retry_count": 3,
-    "event_properties.user_id": "user123"
-  });
+  if (error instanceof Error) {
+    Dynatrace.sendExceptionEvent(new ExceptionEventData(error)
+      .addEventProperty('event_properties.custom_key', 'custom_value')
+      .addEventProperty('event_properties.error_context', 'user_action')
+    );
+  }
 }
 ```
 
 **Parameters:**
 * `error`: The Error object containing exception information (required)
-* `fields`: Optional custom properties following the same naming rules as [sendEvent()](#send-event)
 
 ### 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, HttpRequestEventBuilder } from '@dynatrace/react-native-plugin';
+import { Dynatrace, HttpRequestEventData } from '@dynatrace/react-native-plugin';
 
 // Basic HTTP request event
-const requestBuilder = new HttpRequestEventBuilder('https://api.example.com/users', 'GET');
-Dynatrace.sendHttpRequestEvent(requestBuilder);
+const requestEventData = new HttpRequestEventData('https://api.example.com/users', 'GET');
+Dynatrace.sendHttpRequestEvent(requestEventData);
 
 // HTTP request with additional details
-const detailedBuilder = new HttpRequestEventBuilder('https://api.example.com/data', 'POST')
-  .setResponseCode(200)
-  .setRequestHeaders({ 'Content-Type': 'application/json' });
-Dynatrace.sendHttpRequestEvent(detailedBuilder);
+const detailedRequestEventData = new HttpRequestEventData('https://api.example.com/data', 'POST')
+  .withStatusCode(200)
+  .addEventProperty('event_properties.headers.content_type', 'application/json');
+Dynatrace.sendHttpRequestEvent(detailedRequestEventData);
 ```
 
+**Parameters:**
+* `url`: The URL of the HTTP request (required)
+* `method`: The HTTP method (e.g., 'GET', 'POST', 'PUT', 'DELETE') (required)
+
 ### View Monitoring
 
 The view monitoring APIs allow you to track different screens or views in your application, providing context for all events happening within those views.
 
+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
+
+> **Important:** These approaches should not be mixed, as the outcome is unpredictable. Choose either automatic or manual view monitoring for your application.
+
+#### 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
+  }
+}
+```
+
+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.
+
+For instance, assume the following setup:
+```js
+const Drawer = createDrawerNavigator();
+
+function App() {
+  return (
+    <NavigationContainer>
+      <Drawer.Navigator initialRouteName="Home">
+        <Drawer.Screen name="Home" component={HomeScreen} />
+        <Drawer.Screen name="Feature" component={FeatureScreen}/>
+      </Drawer.Navigator>
+    </NavigationContainer>
+  );
+}
+
+const Stack = createStackNavigator();
+
+function FeatureScreen() {
+  return (
+    <Stack.Navigator initialRouteName="ScreenOne">
+      <Stack.Screen name="ScreenOne" component={NestedScreenOne} />
+      <Stack.Screen name="ScreenTwo" component={NestedScreenTwo} />
+    </Stack.Navigator>
+  );
+}
+```
+
+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`.
+
 #### 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.
@@ -859,41 +993,61 @@ Dynatrace.startView("HomeScreen");
 * View names should be meaningful and consistent across your application
 * All events captured after starting a view will include the view context
 
-#### Stop View
-
-Use `stopView()` to stop monitoring the current view. After stopping, events will no longer include view information.
-
-```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
-
-// Stop the current view monitoring
-Dynatrace.stopView();
-```
-
 **Complete Example:**
 
 ```ts
-import { Dynatrace } from '@dynatrace/react-native-plugin';
+import { Dynatrace, EventData } from '@dynatrace/react-native-plugin';
 
 // User navigates to profile screen
 Dynatrace.startView("UserProfile");
 
 // Send custom event within the view
-Dynatrace.sendEvent({
-  "event_properties.profile_action": "edit_profile",
-  "event_properties.changes_made": true
-});
+Dynatrace.sendEvent(new EventData()
+  .addEventProperty("event_properties.profile_action", "edit_profile")
+  .addEventProperty("event_properties.changes_made", true)
+);
 
 // User navigates away
-Dynatrace.stopView();
+Dynatrace.startView("UserProfileDetailed");
 ```
 
+### React Native Symbolication
+
+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.
+
+#### Generating Sourcemaps
+
+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).
+
+To generate a sourcemap:
+
+**Android:**
+* Run `npx react-native run-android --mode release` in your project root, or
+* Run `gradlew assembleRelease` in the `/android` directory
+
+**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
+
+#### Accounting for Auto-Instrumentation
+
+Since the plugin auto-instruments your code, sourcemap line numbers may be slightly offset. To ensure accurate symbolication:
+
+* **Android**: Automatic patching is **enabled by default** and patches sourcemaps automatically at the end of every release build (see [Source Map](#source-map) configuration)
+* **iOS**: There is currently **no automation** available. You **must** execute [`npx lineOffsetDynatrace`](#npx-lineoffsetdynatrace) to patch your sourcemap files before uploading them to Dynatrace. Without this step, line numbers will be slightly off depending on instrumentation in iOS
+
+#### Uploading Sourcemaps
+
+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).
+
 ## NPX Commands
 
 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
 
@@ -913,6 +1067,19 @@ npx configDynatrace [optional: config=...]
 
 * `config=C:\SpecialFolderForDynatrace\dynatrace.config.js`: If you have not got your config file in the root folder of the React Native project but somewhere else.
 
+## npx lineOffsetDynatrace
+
+Our auto-instrumentation modifies your source code during the build process, which causes line numbers in your sourcemaps to become slightly offset from the original source. This can result in incorrect line numbers when viewing crash reports or stack traces in Dynatrace.
+
+The `npx lineOffsetDynatrace` command patches your sourcemap file with offset information, allowing Dynatrace to accurately map instrumented line numbers back to the original source code. The patching process adds Dynatrace-specific metadata alongside the original sourcemap content without modifying any existing fields, ensuring your sourcemap continues to work as expected with all standard tooling.
+
+**Usage:**
+
+```
+npx lineOffsetDynatrace sourcemapPath=/path/to/your/sourcemap.map
+```
+
+* `sourcemapPath=/path/to/your/sourcemap.map`: **(Required)** The path to the sourcemap file that should be patched.
 
 ## Customizing paths for configuration
 
@@ -960,7 +1127,7 @@ pod 'react-native-dynatrace', :path => '../node_modules/@dynatrace/react-native-
 5. Under Build Phases expand the Link Binary With Libraries header.
 6. Scroll down and click + to add a library.
 7. Find and add `libRNDynatrace.a` under the Workspace group.
-8. ⌘+B
+8. ⌘+B
 
 ## Setup for tvOS
 
@@ -970,7 +1137,7 @@ To allow our plugin to work with tvOS, please follow the below steps:
 
 Before installing the plugin, add the following to your `package.json`:
 
-```js
+```
 "overrides": {
 	"@react-native-picker/picker": {
 		"react-native": "<insert-version-here>"
@@ -983,7 +1150,7 @@ Before installing the plugin, add the following to your `package.json`:
 
 If you are using the following `"react-native": "npm:react-native-tvos@0.69.8-2"`, use the below snippet:
 
-```js
+```
 "overrides": {
 	"@react-native-picker/picker": {
 		"react-native": "0.69.8-2"
@@ -1001,13 +1168,13 @@ Examples:
 
 Using React Native v0.69.x or lower and  @react-native-community/cli v8.x or lower:
 
-```js
+```
 npx react-native run-ios --simulator "Apple TV" --scheme "ApplicationName-tvOS" plist=/path/to/application/ios/ApplicationName-tvOS/Info.plist
 ```
 
 Using React Native v0.70 or higher or @react-native-community/cli v9.x or higher:
 
-```js
+```
 // Update the Info.plist with the properties from the dynatrace.config.js file
 npx instrumentDynatrace plist=/path/to/application/ios/ApplicationName-tvOS/Info.plist
 
@@ -1022,7 +1189,7 @@ For more information regarding the differences in the react native versions, ple
 ## Structure of the `dynatrace.js` file
 The configuration is structured in the following way:
 
-```js
+```ts
 module.exports = {
     react : {
       // Configuration for React Native instrumentation
@@ -1033,7 +1200,7 @@ module.exports = {
     ios : {
       // Configuration for iOS auto instrumentation
     }
-}
+};
 ```
 
 ### Manual Startup Counterparts
@@ -1104,12 +1271,15 @@ This activates the debug mode. You will get more console output during instrumen
 #### Error Handler
 
 ```js
-react: {
-  errorHandler: {
-    enabled: true,
-    reportFatalErrorAsCrash: true,
-  },
-}
+module.exports = {
+  // ...
+  react: {
+    errorHandler: {
+      enabled: true,
+      reportFatalErrorAsCrash: true,
+    },
+  }
+};
 ```
 
 The `enabled` property activates our Error/Crash handler which will insert our handler into your React Native application. This is true per default. 
@@ -1130,13 +1300,67 @@ react: {
 
 This activates the AutoStart mode which will insert an auto start call in your React Native application. This is true per default. If you want to use a manual startup call, please have a look into the [manual startup section](#manual-oneagent-startup).
 
-#### Bundle Name
+#### Bundle Name and Version
+
+By default, the plugin automatically reads the `name` and `version` fields from your `package.json` file and uses them as `bundleName` and `bundleVersion`. These values are included with New RUM on Grail Events and are critical for crash symbolication.
 
-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.
+**Important for Crash Symbolication:**
+When uploading sourcemap files to Dynatrace, you must specify the same `bundleName` and `bundleVersion` values. The sourcemap desymbolication feature requires an exact match between:
+
+* The `bundleName` and `bundleVersion` sent with the crash report
+* The `bundleName` and `bundleVersion` specified when uploading the sourcemap file
+
+If these values don't match, the Error Inspector will not be able to use the sourcemap file to symbolicate the crash.
+
+**Custom Configuration:**
+You can override the default values from `package.json` by explicitly setting them in `dynatrace.config.js`:
+
+```js
+react: {
+  bundleName: "MyCustomBundle",
+  bundleVersion: "1.0.0",
+}
+```
+
+**Multiple Bundle Setup:**
+If you have a multiple bundle setup where you load several `.bundle` files within your React Native application, ensure each bundle has a unique name. This prevents actions from different bundles from interfering with each other.
+
+#### Navigation
+
+This feature is for the New RUM on Grail experience only and is described in the [Automatic Navigation tracking](#automatic-navigation-tracking) section.
+
+```js
+react: {
+  navigation: {
+    enabled: true
+  }
+}
+```
+
+#### Source Map
+
+This feature is enabled by default and patches sourcemap files so that any modifications made through Dynatrace will result in correct line numbers. If this feature is not enabled, line numbers of symbolicated stacktraces in Dynatrace might not match with your original source.
+
+The following is an example of how this feature can be configured in your `dynatrace.config.js` file:
 
 ```js
 react: {
-  bundleName: "MyCustomBundle"
+  sourceMap: { 
+    enabled: true
+  }
+}
+```
+
+> **Note:** This automatic patching only works for Android. For iOS, you need to manually call [lineOffsetDynatrace](#npx-lineoffsetdynatrace) after the creation of the sourcemap is finished or before uploading it to Dynatrace.
+
+The automatic patching for Android can be customized using the `androidSourcemapLocation` property to specify a custom path to your sourcemap file, resolving from the `android/` directory since that is where the automation gets executed:
+
+```js
+react: {
+  sourceMap: { 
+    enabled: true,
+    androidSourcemapLocation: 'sourcemap.map'
+  }
 }
 ```
 
@@ -1333,6 +1557,9 @@ ios: {
 We check for a property named `dtActionName` when creating an action. If `dtActionName` exists, this will be used for the action name above every other option listed in the previous section. Example: 
 
 ```js
+import { TouchableHighlight } from '@dynatrace/react-native-plugin';
+import { Text } from 'react-native';
+
 <TouchableHighlight dtActionName="CustomActionName">
   <Text>Custom Action Name</Text>
 </TouchableHighlight>
@@ -1448,10 +1675,10 @@ This can be done via a configuration value in the `dynatrace.config.js`. The fol
 module.exports = {
     react : {
         upstreamTransformer: require.resolve('react-native-svg-transformer/react-native'),
-        ...
+        // ...
     },
-    ...       
-}
+    // ...       
+};
 ```
 
 #### metro.config.js for React Native v0.72.1 or newer
@@ -1474,7 +1701,7 @@ const config = {
   },
   reporter: require('@dynatrace/react-native-plugin/lib/dynatrace-reporter'),
   resolver: {
-    assetExts: assetExts.filter(ext => ext !== 'svg'),
+    assetExts: assetExts.filter((ext) => ext !== 'svg'),
     sourceExts: [...sourceExts, 'cjs', 'svg'],
   },
 };
@@ -1611,7 +1838,7 @@ If you encounter compatibility issues or want to disable Jetpack Compose instrum
 
 ```js
 module.exports = {
-  ...
+  // ...
   android: {
         config: `
         dynatrace {
@@ -1623,8 +1850,9 @@ module.exports = {
                 }
             }
         }
-        `
-  },
+        `,
+  }
+};
 ```
 
 For more information about Jetpack Compose instrumentation and monitoring capabilities, please refer to the [official Dynatrace documentation for Android OneAgent](https://docs.dynatrace.com/docs/observe/digital-experience/mobile-applications/instrument-android-app/instrumentation-via-plugin/monitoring-capabilities#compose-enable).
@@ -1722,21 +1950,44 @@ In case you are using NativeWind, use 'nativewind' as the importSource for the J
 >**Attention:** If you think something is not working the way it should, ALWAYS try to reset the cache of metro first before starting a support case. You can do this via the CLI *react-native start --reset-cache*. If it still does not work feel free to open a support case.
 
 If you are struggling with a problem, submit a support ticket to Dynatrace (support.dynatrace.com) and provide the following details:
-* Logs from the [native agent](#native-oneagent-debug-logs)
-* Logs from `node_modules/@dynatrace/react-native-plugin/logs`
-* Your dynatrace.config.js file
+
+### Files to gather:
+
+1. **Native agent logs** - Enable [native agent debug logs](#native-oneagent-debug-logs) and collect logs from:
+   * **iOS**: Xcode console output
+   * **Android**: Android Studio Logcat
+
+2. **Metro logs** - Enable [React debug mode](#debug-mode) in your `dynatrace.config.js` and collect Metro bundler logs:
+   * Build logs showing instrumentation output
+   * Runtime logs from Metro terminal/console
+   * These logs show React Native side instrumentation and runtime behavior
+
+3. **Plugin logs** - Located in `node_modules/@dynatrace/react-native-plugin/logs`
+
+4. **Configuration** - Your `dynatrace.config.js` file
+
+>**Tip:** Enable both native agent debug logs and React debug mode before reproducing the issue to capture comprehensive diagnostics from both native (iOS/Android) and JavaScript (React Native) layers.
+
 <br/><br/>
 ## Changelog
 
+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
+* 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
+
 2.327.2
 * Fixed iOS startup time calculation issues for React Native 0.72 and lower
 * Fixed static properties during auto instrumentation of Touchables
 * Updated Android (8.327.3.1006) & iOS Agent (8.327.2.1022)
 
-
 2.327.1
 * Added [Compose Compatibility Note](#compose-compatibility-note)
-* Added [New RUM experience preview](#new-rum-experience-preview) documentation
+* Added [New RUM experience preview](#new-rum-experience) 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)
 
@@ -1745,8 +1996,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-preview) ReactNative version now added to RUM on Grail event base data
-* [New RUM experience preview](#new-rum-experience-preview) Added API documentation for RUM on Grail API
+* [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
 
 2.323.2
 * Fixed error "Execution failed for task ':app:mergeReleaseAssets'. A problem occured starting process 'command 'npx''" when building for release on Windows.