Android SDK Advanced Configuration

About Dependencies and Package NamesFlashduty Android SDK is fully compatible with the Datadog open-source protocol. In build.gradle, use cloud.flashcat group for dependencies, but in Kotlin/Java code, import classes from the com.datadog.android package. You can seamlessly leverage Datadog ecosystem documentation, examples, and best practices while enjoying Flashduty platform services.

Flashduty Android RUM SDK provides rich advanced configuration options to help you customize data collection and context information based on business needs.

Supported Configuration Scenarios:

Enrich user sessions - Add custom views, actions, resources, and error information
Protect sensitive data - Mask personally identifiable information and sensitive data
Associate user sessions - Link user sessions with internal user identifiers
Control data volume - Optimize data collection through sampling and event filtering
Enhance context - Add custom attributes to data

Enrich User Sessions

Custom Views

When using ActivityViewTrackingStrategy or FragmentViewTrackingStrategy, the RUM SDK automatically tracks views. You can also manually send custom RUM views when a view becomes visible or interactive.

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor

fun onResume() {
    GlobalRumMonitor.get().startView(viewKey, viewName, attributes)
}

fun onPause() {
    GlobalRumMonitor.get().stopView(viewKey, attributes)
}

import com.datadog.android.rum.GlobalRumMonitor;

public void onResume() {
    GlobalRumMonitor.get().startView(viewKey, viewName, attributes);
}

public void onPause() {
    GlobalRumMonitor.get().stopView(viewKey, attributes);
}

Parameter Description:

viewKey (String) - Unique identifier for the view, same viewKey used for startView() and stopView()
viewName (String) - Name of the view
attributes (Map<String, Any?>) - Attributes attached to the view (optional)

Custom Actions

In addition to auto-tracked user interactions, you can track specific custom user actions (like clicks, swipes, likes).

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor
import com.datadog.android.rum.RumActionType

fun onUserInteraction() {
    GlobalRumMonitor.get().addAction(
        RumActionType.TAP,
        name,
        attributes
    )
}

import com.datadog.android.rum.GlobalRumMonitor;
import com.datadog.android.rum.RumActionType;

public void onUserInteraction() {
    GlobalRumMonitor.get().addAction(
        RumActionType.TAP,
        name,
        attributes
    );
}

RumActionType Enum Values

Type	Description	Use Case
`RumActionType.TAP`	Tap action	Button, icon taps
`RumActionType.SCROLL`	Scroll action	List, page scrolling
`RumActionType.SWIPE`	Swipe action	Swipe transitions, gestures
`RumActionType.CLICK`	Click action	General clicks
`RumActionType.CUSTOM`	Custom action	Business-specific actions

Custom Resources

In addition to auto-tracked resources, you can manually track specific custom resources (like network requests, third-party library loading).

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor
import com.datadog.android.rum.RumResourceKind

fun loadResource() {
    GlobalRumMonitor.get().startResource(resourceKey, method, url, attributes)
}

fun resourceLoadSuccess() {
    GlobalRumMonitor.get().stopResource(
        resourceKey, statusCode, size, 
        RumResourceKind.NATIVE, attributes
    )
}

fun resourceLoadError() {
    GlobalRumMonitor.get().stopResourceWithError(
        resourceKey, statusCode, message, source, throwable
    )
}

import com.datadog.android.rum.GlobalRumMonitor;
import com.datadog.android.rum.RumResourceKind;

public void loadResource() {
    GlobalRumMonitor.get().startResource(resourceKey, method, url, attributes);
}

public void resourceLoadSuccess() {
    GlobalRumMonitor.get().stopResource(
        resourceKey, statusCode, size, 
        RumResourceKind.NATIVE, attributes
    );
}

public void resourceLoadError() {
    GlobalRumMonitor.get().stopResourceWithError(
        resourceKey, statusCode, message, source, throwable
    );
}

RumResourceKind Resource Types

Type	Description	Use Case
`BEACON`	Beacon request	Analytics reporting
`FETCH`	Fetch request	Modern async requests
`XHR`	XHR request	Traditional Ajax
`DOCUMENT`	Document resource	HTML documents
`IMAGE`	Image resource	Image loading
`JS`	JavaScript resource	JS files
`FONT`	Font resource	Font files
`CSS`	CSS resource	Style files
`MEDIA`	Media resource	Audio/video files
`NATIVE`	Native resource	Native module loading
`OTHER`	Other resource	Uncategorized resources

Custom Errors

To record specific errors, notify the RUM SDK when an exception occurs:

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor

GlobalRumMonitor.get().addError(
    message,
    source,
    throwable,
    attributes
)

import com.datadog.android.rum.GlobalRumMonitor;

GlobalRumMonitor.get().addError(
    message,
    source,
    throwable,
    attributes
);

For more error reporting details, see Android Error Reporting.

Custom Timing

In addition to RUM SDK’s default performance metrics, you can use the addTiming API to measure the duration of key operations. Timing is an offset relative to the current RUM view start time.

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor

fun onHeroImageLoaded() {
    GlobalRumMonitor.get().addTiming("hero_image")
}

import com.datadog.android.rum.GlobalRumMonitor;

public void onHeroImageLoaded() {
    GlobalRumMonitor.get().addTiming("hero_image");
}

After setting timing, access it via @view.custom_timings.<timing_name>, e.g., @view.custom_timings.hero_image.

Set User Information

The RUM SDK supports standard user information.

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor

GlobalRumMonitor.get().setUserInfo(
    id = "1234",
    name = "John Doe",
    email = "john@doe.com"
)

import com.datadog.android.rum.GlobalRumMonitor;

GlobalRumMonitor.get().setUserInfo(
    "1234",
    "John Doe",
    "john@doe.com",
    null
);

Only standard user fields are supported: id, name, email, and anonymous_id. Other user attributes are not supported. If needed, configure them under context.

Event and Data Management

Clear All Data

Use clearAllData to clear all unsent data currently stored in the SDK:

Kotlin
Java

import com.datadog.android.Datadog

Datadog.clearAllData()

import com.datadog.android.Datadog;

Datadog.clearAllData();

Stop Data Collection

Use stopInstance to stop collecting data and clear all local data:

Kotlin
Java

import com.datadog.android.Datadog

Datadog.stopInstance()

import com.datadog.android.Datadog;

Datadog.stopInstance();

After you call stopInstance(), the SDK stops working entirely. You have to initialize it again to resume data collection.

Control Event Batch Upload

The RUM SDK uploads events in batches automatically. You can control that behavior with configuration parameters:

Kotlin
Java

import com.datadog.android.core.configuration.Configuration
import com.datadog.android.core.configuration.UploadFrequency

val configuration = Configuration.Builder(
    clientToken = clientToken,
    env = environmentName,
    variant = appVariantName
)
    .setBatchSize(batchSize)
    .setUploadFrequency(UploadFrequency.FREQUENT)
    .build()

import com.datadog.android.core.configuration.Configuration;
import com.datadog.android.core.configuration.UploadFrequency;

Configuration configuration = new Configuration.Builder(
    clientToken, environmentName, appVariantName
)
    .setBatchSize(batchSize)
    .setUploadFrequency(UploadFrequency.FREQUENT)
    .build();

UploadFrequency

Frequency	Description	When to use
`FREQUENT`	Upload often	Scenarios that need data to arrive quickly
`AVERAGE`	Upload at a moderate pace	Default. Balances performance and freshness
`RARE`	Upload sparingly	Saves bandwidth and battery

Set Remote Log Threshold

You can define a minimum log level for remotely recorded messages. Logs below that level are not sent to Flashduty:

Kotlin
Java

import com.datadog.android.log.Logs
import com.datadog.android.log.LogsConfiguration
import android.util.Log

val logsConfig = LogsConfiguration.Builder()
    .setRemoteSampleRate(100f)
    .setRemoteLogThreshold(Log.WARN)
    .build()
    
Logs.enable(logsConfig)

import com.datadog.android.log.Logs;
import com.datadog.android.log.LogsConfiguration;
import android.util.Log;

LogsConfiguration logsConfig = new LogsConfiguration.Builder()
    .setRemoteSampleRate(100f)
    .setRemoteLogThreshold(Log.WARN)
    .build();
    
Logs.enable(logsConfig);

With a Log.WARN threshold, only WARN and ERROR logs are uploaded. DEBUG and INFO logs are filtered out.

Track Custom Global Attributes

Beyond the default attributes the RUM SDK captures automatically, you can attach extra context to RUM events, such as custom attributes.

What custom attributes are for:

Filter and group user behavior by business information, such as cart state, user tier, or marketing campaign
Follow the browsing path of a specific user
Understand which users are hit hardest by an error
Monitor performance for your most important users

Track User Sessions

To identify user sessions, call the setUserInfo API after initializing the SDK:

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor

GlobalRumMonitor.get().setUserInfo(
    id = "1234",
    name = "John Doe",
    email = "john@doe.com"
)

import com.datadog.android.rum.GlobalRumMonitor;

GlobalRumMonitor.get().setUserInfo("1234", "John Doe", "john@doe.com", null);

Only the standard user fields are supported: id, name, email and anonymous_id. Other user properties are not. If you need more, put them in the context field.

Parameters:

id (String) - Unique user identifier
name (String) - Friendly user name, shown in the RUM UI by default
email (String) - User email, shown when no name is available
All of these are optional, but you should provide at least one

Track Attributes

Global attributes are attached to every RUM event and are useful for adding shared context. Add a global attribute:

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor

GlobalRumMonitor.get().addAttribute("key", "value")

import com.datadog.android.rum.GlobalRumMonitor;

GlobalRumMonitor.get().addAttribute("key", "value");

Remove a global attribute:

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor

GlobalRumMonitor.get().removeAttribute("key")

import com.datadog.android.rum.GlobalRumMonitor;

GlobalRumMonitor.get().removeAttribute("key");

Track Widgets

Widgets are not tracked automatically. To monitor widget interactions, call the API yourself.

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor
import com.datadog.android.rum.RumActionType

fun onWidgetClicked() {
    GlobalRumMonitor.get().addAction(
        RumActionType.TAP,
        "widget_clicked",
        mapOf("widget_name" to "HomeWidget")
    )
}

import com.datadog.android.rum.GlobalRumMonitor;
import com.datadog.android.rum.RumActionType;
import java.util.HashMap;
import java.util.Map;

public void onWidgetClicked() {
    Map<String, Object> attributes = new HashMap<>();
    attributes.put("widget_name", "HomeWidget");
    GlobalRumMonitor.get().addAction(
        RumActionType.TAP,
        "widget_clicked",
        attributes
    );
}

Initialization Parameters

When you initialize the Flashduty Android SDK, Configuration.Builder gives you several options.

Automatically Track Views

To track views (activities and fragments) automatically, call useViewTrackingStrategy during initialization:

Kotlin
Java

import com.datadog.android.rum.RumConfiguration
import com.datadog.android.rum.tracking.ActivityViewTrackingStrategy

val rumConfig = RumConfiguration.Builder(applicationId)
    .useViewTrackingStrategy(ActivityViewTrackingStrategy(true))
    .build()

import com.datadog.android.rum.RumConfiguration;
import com.datadog.android.rum.tracking.ActivityViewTrackingStrategy;

RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
    .useViewTrackingStrategy(new ActivityViewTrackingStrategy(true))
    .build();

Available tracking strategies

Strategy	Parameters	Description	When to use
`ActivityViewTrackingStrategy`	`trackExtras`	Tracks each activity as its own view	Traditional activity-based architecture
`FragmentViewTrackingStrategy`	`trackArguments`	Tracks each fragment as its own view	Fragment-oriented apps
`MixedViewTrackingStrategy`	`trackExtras`, `trackArguments`	Tracks both activities and fragments	Mixed architecture
`NavigationViewTrackingStrategy`	`navigationViewId`	Tracks Navigation component destinations	Apps using Jetpack Navigation

Automatically Track Network Requests

To track HTTP requests automatically, see the OkHttp interceptor setup in the SDK integration guide.

Automatically Track Apollo GraphQL Requests

If you use the Apollo GraphQL client for network calls, you can enable automatic tracking.

Add the Apollo dependency

Add the dependency to your app’s build.gradle file:

build.gradle

dependencies {
    implementation "cloud.flashcat:dd-sdk-android-apollo:<latest-version>"
}

Check the Maven Central versions page for the latest version number.

Configure the Apollo client

Kotlin
Java

import com.apollographql.apollo.ApolloClient
import com.apollographql.apollo.network.okHttpClient
import com.datadog.android.apollo.DatadogApolloInterceptor

val apolloClient = ApolloClient.Builder()
    .serverUrl("GraphQL endpoint")
    .addInterceptor(DatadogApolloInterceptor())
    .okHttpClient(okHttpClient)
    .build()

import com.apollographql.apollo.ApolloClient;
import com.datadog.android.apollo.DatadogApolloInterceptor;

ApolloClient apolloClient = new ApolloClient.Builder()
    .serverUrl("GraphQL endpoint")
    .addInterceptor(new DatadogApolloInterceptor())
    .okHttpClient(okHttpClient)
    .build();

Flashduty tracing headers are added to your GraphQL requests automatically, which makes them traceable.

Limitations:

Only Apollo version 4 is supported
Only query and mutation operations are tracked; subscription operations are not

Send GraphQL payloads (optional):

Kotlin
Java

DatadogApolloInterceptor(sendGraphQLPayloads = true)

new DatadogApolloInterceptor(true)

Automatically Track Long Tasks

Long-running work on the main thread can hurt your app’s visual performance and responsiveness. The SDK can detect and track long tasks automatically.

Kotlin
Java

import com.datadog.android.rum.RumConfiguration

// Use the default threshold (100ms)
val rumConfig = RumConfiguration.Builder(applicationId)
    .trackLongTasks(durationThreshold)
    .build()

// Use a custom threshold (250ms)
val rumConfig = RumConfiguration.Builder(applicationId)
    .trackLongTasks(250L)
    .build()

import com.datadog.android.rum.RumConfiguration;

// Use the default threshold (100ms)
RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
    .trackLongTasks(durationThreshold)
    .build();

// Use a custom threshold (250ms)
RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
    .trackLongTasks(250L)
    .build();

The default threshold is 100ms. Adjust it to match your app’s performance requirements.

Modify or Discard RUM Events

To modify some attributes of a RUM event before it is batched, or to discard events entirely, provide an implementation of EventMapper<T> at initialization.

Kotlin
Java

import com.datadog.android.rum.RumConfiguration

val rumConfig = RumConfiguration.Builder(applicationId)
    .setErrorEventMapper(rumErrorEventMapper)
    .setActionEventMapper(rumActionEventMapper)
    .setResourceEventMapper(rumResourceEventMapper)
    .setViewEventMapper(rumViewEventMapper)
    .setLongTaskEventMapper(rumLongTaskEventMapper)
    .build()

import com.datadog.android.rum.RumConfiguration;

RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
    .setErrorEventMapper(rumErrorEventMapper)
    .setActionEventMapper(rumActionEventMapper)
    .setResourceEventMapper(rumResourceEventMapper)
    .setViewEventMapper(rumViewEventMapper)
    .setLongTaskEventMapper(rumLongTaskEventMapper)
    .build();

Modifiable Event Attributes

When you implement the EventMapper<T> interface, only some attributes can be modified for each event type:

ViewEvent modifiable attributes

Attribute key	Description
`view.referrer`	URL that linked to the initial view of the page
`view.url`	URL of the view
`view.name`	Name of the view

ActionEvent modifiable attributes

Attribute key	Description
`action.target.name`	Target name
`view.referrer`	URL that linked to the initial view of the page
`view.url`	URL of the view
`view.name`	Name of the view

ErrorEvent modifiable attributes

Attribute key	Description
`error.message`	Error message
`error.stack`	Stack trace of the error
`error.resource.url`	URL of the resource
`view.referrer`	URL that linked to the initial view of the page
`view.url`	URL of the view
`view.name`	Name of the view

ResourceEvent modifiable attributes

Attribute key	Description
`resource.url`	URL of the resource
`view.referrer`	URL that linked to the initial view of the page
`view.url`	URL of the view
`view.name`	Name of the view

LongTaskEvent modifiable attributes

Attribute key	Description
`view.referrer`	URL that linked to the initial view of the page
`view.url`	URL of the view
`view.name`	Name of the view

If your EventMapper<T> implementation returns null, the event is discarded and never sent to Flashduty.

Example: Discard Sensitive Errors

Kotlin
Java

val rumConfig = RumConfiguration.Builder(applicationId)
    .setErrorEventMapper { errorEvent ->
        if (errorEvent.error.message?.contains("sensitive_data") == true) {
            null // Discard errors that contain sensitive data
        } else {
            errorEvent
        }
    }
    .build()

RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
    .setErrorEventMapper(errorEvent -> {
        if (errorEvent.error.message != null &&
            errorEvent.error.message.contains("sensitive_data")) {
            return null; // Discard errors that contain sensitive data
        } else {
            return errorEvent;
        }
    })
    .build();

Get the RUM Session ID

Retrieving the RUM session ID is useful for troubleshooting. You can attach it to support requests, emails or error reports so the support team can find the user’s session in Flashduty.

Kotlin
Java

import com.datadog.android.rum.GlobalRumMonitor

GlobalRumMonitor.get().getCurrentSessionId { sessionId ->
    currentSessionId = sessionId
}

import com.datadog.android.rum.GlobalRumMonitor;

GlobalRumMonitor.get().getCurrentSessionId(sessionId -> {
    currentSessionId = sessionId;
});

You can read the RUM session ID at runtime without waiting for the sessionStarted event.

Sampling Control

By default, RUM collects data for every session. You can reduce the number of collected sessions by setting a sample rate through the sessionSampleRate parameter.

Kotlin
Java

import com.datadog.android.rum.RumConfiguration

val rumConfig = RumConfiguration.Builder(applicationId)
    .setSessionSampleRate(90.0f) // Collect 90% of sessions
    .build()

import com.datadog.android.rum.RumConfiguration;

RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
    .setSessionSampleRate(90.0f) // Collect 90% of sessions
    .build();

Sample rate range: 0.0 - 100.0

100.0 - Collect every session (default)
50.0 - Collect 50% of sessions
0.0 - Collect no sessions

Sampled-out sessions collect no page views and none of the related telemetry data.

Remote configuration: adjust the sample rate from the console

Since 0.7.0, the session sample rate can be changed on the Remote configuration page of the Flashcat console without shipping a new release of your app. The feature is off by default; turn it on at initialization:

Kotlin
Java

val rumConfig = RumConfiguration.Builder(applicationId)
    .setSessionSampleRate(90.0f)          // Used until the console's settings arrive
    .setRemoteConfigurationEnabled(true)  // Let the console set the session sample rate
    .build()

RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
    .setSessionSampleRate(90.0f)          // Used until the console's settings arrive
    .setRemoteConfigurationEnabled(true)  // Let the console set the session sample rate
    .build();

How a change takes effect:

The SDK asks the console for the configuration once at startup and once whenever a new session starts. What it receives is used to draw the next session; a session already under way is never redrawn.
The exception is a rate that crosses zero (from 0 to non-zero, or from non-zero to 0): the running session ends immediately and the next one is drawn under the new rate, so an emergency stop or a restart does not wait for sessions to rotate.
When the request fails, times out or returns an unreadable response, the SDK keeps the values already in use; before the first configuration ever arrives, the value passed to setSessionSampleRate applies. The configuration is cached on the device, so the first session of the next cold start already uses it.
The request carries only the client token, the environment, the app version and the SDK version, never user data, so it is not gated by the tracking consent state.
In a private deployment the configuration endpoint sits beside the RUM intake under /config (for an intake of https://host/api/v2/rum, it is https://host/api/v2/rum/config). When you use useCustomEndpoint, make sure your gateway lets that path through.

Override the draw from your app

To guarantee that certain users are always collected (internal testers, a user whose issue you are investigating), setBeforeSampling lets the app have the last word before each draw. Return null to keep the incoming rate. A value outside 0..100, or a callback that throws, also leaves the incoming rate in place and never disrupts collection.

Kotlin
Java

val rumConfig = RumConfiguration.Builder(applicationId)
    .setRemoteConfigurationEnabled(true)
    .setBeforeSampling { context ->
        // context.sessionSampleRate is the rate from the console (or from init)
        // context.custom holds the key-values published under "Custom configuration"
        if (isInternalTester()) 100f else null
    }
    .build()

RumConfiguration rumConfig = new RumConfiguration.Builder(applicationId)
    .setRemoteConfigurationEnabled(true)
    .setBeforeSampling(context -> isInternalTester() ? 100f : null)
    .build();

While the app is running you can also call setForcedSession() at any time to collect every session of this user from now until the process ends:

GlobalRumMonitor.get().setForcedSession()

Read the console’s custom configuration

The values published under “Custom configuration” on the Remote configuration page are delivered to the SDK verbatim and can be read with getRemoteConfig(). The SDK never interprets them; what they mean is entirely up to your app. It returns null when nothing is published or remote configuration is off.

val custom = GlobalRumMonitor.get().getRemoteConfig()
val debugUsers = custom?.get("debugUsers") as? List<*>

Custom configuration is visible to every client running the SDK. Never put secrets, tokens or personal data in it.

To comply with privacy regulations such as GDPR and CCPA, RUM lets you set the user tracking consent state at initialization.

State	Behavior	When to use
`TrackingConsent.GRANTED`	Start collecting data and send it to Flashduty	The user has agreed to data collection
`TrackingConsent.NOT_GRANTED`	Collect no data	The user has declined data collection
`TrackingConsent.PENDING`	Collect data but do not send it	Waiting for the user to decide

If you initialize with TrackingConsent.PENDING, the SDK starts collecting data but sends nothing until the consent state changes to GRANTED.

You can change the consent state after initialization through the setTrackingConsent API:

Kotlin
Java

import com.datadog.android.Datadog
import com.datadog.android.privacy.TrackingConsent

Datadog.setTrackingConsent(TrackingConsent.GRANTED)

import com.datadog.android.Datadog;
import com.datadog.android.privacy.TrackingConsent;

Datadog.setTrackingConsent(TrackingConsent.GRANTED);

Best Practices

View tracking

Call startView and stopView in the right lifecycle methods so views are not tracked twice
Use a unique viewKey for each view

Resource tracking

When tracking resources manually, pair every startResource with a matching stopResource or stopResourceWithError
Avoid tracking internal resources or requests that fire very frequently

Event modification

Only the attributes listed in the tables above can be modified; changes to any other attribute are ignored
Return null to discard the whole event

Performance

Tune the sample rate and batch upload frequency together to balance data volume against overhead
Avoid slow work inside event callbacks

SDK Integration

Learn how to quickly integrate the RUM SDK

Data Collection

Learn about data types and attributes collected by the SDK

Compatibility

Learn about SDK compatibility requirements

​Enrich User Sessions

​Custom Views

​Custom Actions

​Custom Resources

​Custom Errors

​Custom Timing

​Set User Information

​Event and Data Management

​Clear All Data

​Stop Data Collection

​Control Event Batch Upload

​Set Remote Log Threshold

​Track Custom Global Attributes

​Track User Sessions

​Track Attributes

​Track Widgets

​Initialization Parameters

​Automatically Track Views

​Automatically Track Network Requests

​Automatically Track Apollo GraphQL Requests

​Automatically Track Long Tasks

​Modify or Discard RUM Events

​Modifiable Event Attributes

​Example: Discard Sensitive Errors

​Get the RUM Session ID

​Sampling Control

​Remote configuration: adjust the sample rate from the console

​Override the draw from your app

​Read the console’s custom configuration

​User Tracking Consent

​Consent States

​Change Consent State

​Best Practices

​Related Documentation

SDK Integration

Data Collection

Compatibility

Enrich User Sessions

Custom Views

Custom Actions

Custom Resources

Custom Errors

Custom Timing

Set User Information

Event and Data Management

Clear All Data

Stop Data Collection

Control Event Batch Upload

Set Remote Log Threshold

Track Custom Global Attributes

Track User Sessions

Track Attributes

Track Widgets

Initialization Parameters

Automatically Track Views

Automatically Track Network Requests

Automatically Track Apollo GraphQL Requests

Automatically Track Long Tasks

Modify or Discard RUM Events

Modifiable Event Attributes

Example: Discard Sensitive Errors

Get the RUM Session ID

Sampling Control

Remote configuration: adjust the sample rate from the console

Override the draw from your app

Read the console’s custom configuration

User Tracking Consent

Consent States

Change Consent State

Best Practices

Related Documentation