New RUM APIs

• Reference
• 10-min read
• Published Aug 07, 2025

Report Events

Dynatrace.sendEvent

Sends a user event with the given fields to the Dynatrace Platform.

The provided fields must be a valid JSON object. Nested objects or arrays are not allowed.

The event will be filled with the provided fields and enriched with basic context information such as user session details and frontend metadata. After auto-enrichment, the event can be modified using an EventModifier. At this stage, it's also possible to use the provided event context objects for further manual enrichment of the event.

Dynatrace.sendSessionPropertyEvent

Sends a session properties event.

With sendSessionPropertyEvent, you can report properties that apply to all events in the current session. Any custom properties must be added in the session_properties.* namespace, otherwise they will be dropped. Even though you can send multiple sessions properties at once, session aggregation will take only one of the values (first or last) if you report the same value multiple times.

Fields must contain only alphanumeric characters, underscores and dots. Each dot must be followed by a lowercase character. Each underscore must followed by a lowercase character or number.

Properties require a server-side configuration in the settings UI. Otherwise, they'll be dropped during ingest.

Report Errors

Dynatrace.sendExceptionEvent

Sends exception event with a Throwable and EventFieldsProvider.

The EventFieldsProvider is a functional interface that returns a JSONObject containing custom fields that should be added to the event.

If a given Throwable is null, no event is reported to the system.

Modifying Events

Dynatrace.addEventModifier

Adds an EventModifier that enriches future events by applying the modifier function to them. When adding a field, you must use the event property namespace.

Certain reserved fields and namespaces can’t be modified (added, removed, or overridden) in any way, while others are open for modification.

Dynatrace.removeEventModifier

Removes a previously added EventModifier.

EventModifier

Android

EventModifier is a functional interface that provides a modifier function that is used to enrich a given event as JSONObject. It receives context objects depending on the type of the event or null if no context is available. The returned event can be a modified version of the event JSON or null if the event should be dropped.

JSONObject modifyEvent(JSONObject event, Object[] eventContext)

It receives context objects depending on the type of the event or null if no context is available. The returned event can be a modified version of the event JSON or null if the event should be dropped.

The following context parameters are to be expected on Android:

iOS

The eventModifier provides a closure that can be used to enrich an event as [String: Any]. Additionally, it may receive a context that can be used to additionally enrich the event.

eventModifier: (DTXModifyableEvent, Any?) -> DTXModifyableEvent?

It receives context objects depending on the type of the event or null if no context is available. The returned event can be a modified version of the event JSON or null if the event should be dropped.

The following context parameters are to be expected on iOS:

React Native

EventModifier is a functional interface that provides a modifier function that is used to enrich a given event as JSONObject. It receives context objects depending on the type of the event or null if no context is available. The returned event can be a modified version of the event JSON or null if the event should be dropped.

modifyEvent(event: JSONObject | null, context?: any): JSONObject | null

It receives context objects depending on the type of the event or null if no context is available. The returned event can be a modified version of the event JSON or null if the event should be dropped.

The following context parameters are to be expected on Android:

Flutter

EventModifier is a functional interface that provides a modifier function that is used to enrich a given event as JSONObject. It receives context objects depending on the type of the event or null if no context is available. The returned event can be a modified version of the event JSON or null if the event should be dropped.

Map<String, dynamic>? modifyEvent(Map<String, dynamic>? event, dynamic context)

It receives context objects depending on the type of the event or null if no context is available. The returned event can be a modified version of the event JSON or null if the event should be dropped.

The following context parameters are to be expected on Android:

View Tracking for mobile

A view refers to a view/screen/window which is presented to the user at any time. The view-context can be used to analyze a users' flow from one view to another or how much time was spent on a certain view. It’s also useful to contextualize errors/crashes and other performance data, associate it with team ownership and more. That’s why Dynatrace offers this API to manually add the view context to captured user events.

Dynatrace plans to automatically detect views in one of the upcoming releases based on major mobile project setups.

Dynatrace.startView

Starts monitoring of a view.

On every opening of a view the startView method can be called to highlight the current view context of the user. All events captured thereafter can be evaluated in context of that view. When another view was started previously, then this method will stop view monitoring for the previous view and start it for the current view.

Dynatrace.stopView

Stops monitoring of the view that was previously started via startView(String). It will remove the view context and all events captured afterwards will be reported without view information.

ANR Reporting for mobile

With the New RUM Experience, Dynatrace automatically captures “Application Not Responding”(ANR) errors. ANRs are critical to monitor as they cause frustration to the user. The main problem is that the app's main thread, which is responsible for updating the UI, can't process user input events or draw, forcing the app to be closed.

These events are sent only if the mobile app is restarted within a timeframe of 10 minutes by the user.

By default, this feature is turned on. To turn it off use the following configuration options:

Android

OneAgent only reports ANR errors on devices with Android 11 or higher. On older Android versions, the ANR Error event is not available.

Using the ConfigurationBuilder when starting the agent manually:

public ConfigurationBuilder withAnrReporting(boolean enabled)

Using the DSL:

dynatrace {
    configurations {
       sampleConfig {
         anrReporting false
         ...
       }
    }
}

iOS

Using the dictionary configuration when starting the agent manually:

Dynatrace.startup(withConfig: ["DTXANRReportingEnabled": false, …])

Using the plist file:

<key>DTXANRReportingEnabled</key>
<false/>

React Native

Using the dynatrace.config.js file:

module.exports = {
    react: {
        ...
    },
    android: {
        // Those configs are copied 1:1
        config: `
        dynatrace {
            configurations {
                defaultConfig {
                    ...
                    anrReporting false
                }
            }
        }
        `
    },
    ios: {
        // Those configs are copied 1:1
        config: `
        ...
        <key>DTXANRReportingEnabled</key>
        <false/>
        `
    }

Flutter

Using the dynatrace.config.yaml file:

android:
  config:
    "dynatrace {
      configurations {
        defaultConfig {
          ...
          anrReporting false
        }
      }
    }"

ios:
  config:
    "...
    <key>DTXANRReportingEnabled</key>
    <false/>"

Native Crash Reporting for Android

Native crashes are crashes that originate in C/C++ code added via NDK. The official Android documentation lists examples and how to diagnose them.

With the New RUM Experience, Dynatrace automatically captures native crashes. Events are sent only if the mobile app is restarted within a timeframe of 10 minutes by the end user.

By default, this feature is turned on. To turn it off use the following configuration options:

Enable new RUM capturing on Grail as default for mobile

Once new RUM is enabled for a mobile app monitored by Dynatrace, data is stored on Grail. On each end user device on which the mobile app is installed, the new configuration will be applied only after the first session is finished. Upon the very first app start OneAgent will initiate non-Grail communication and upgrade to Grail only if ordered by server configuration, and only on the next app start.

Hence, the first session will be captured only on RUM Classic, unless the following build-time configuration is additionally applied:

Android

To avoid that and to start with Grail right away, the startupWithGrailEnabled flag must be set to true.

This can be done using the ConfigurationBuilder:

public ConfigurationBuilder withStartupWithGrailEnabled(boolean enabled)

Using the DSL:

dynatrace {
    configurations {
       sampleConfig {
         agentBehavior{
           startupWithGrailEnabled true
         }
       }
    }
}

iOS

To avoid that and to start with Grail right away, the DTXStartupWithGrailEnabled flag must be set to true.

This can be done in the .plist file:

<key>DTXStartupWithGrailEnabled</key>
<true/>

If the Dynatrace.startup(withConfig:) method is used, it needs to be added there.

Dynatrace.startup(withConfig: ["DTXStartupWithGrailEnabled": true, …])

Add custom OkHttp client to Android

OneAgent for Android now allows you to specify a custom OkHttp client to use for network requests, that are used to transmit RUM data to Grail.

This can be set using manual startup with the ConfigurationBuilder:

public ConfigurationBuilder withOkHttpClient(okhttp3.OkHttpClient httpClient)

Likewise, an OkHttp factory can be provided to achieve the same result:

public ConfigurationBuilder withOkHttpFactory(okhttp3.Call.Factory httpFactory)

IdentifyUser

Use to identify individual users across different browsers, devices, and user sessions.

Limitations

Mobile-specific limitations