Overview

If you experience unexpected behavior with Datadog RUM, use this guide to resolve issues. If you continue to have trouble, contact Datadog Support for further assistance.

Check if Datadog RUM is initialized

Use the utility method isInitialized to check if the SDK is properly initialized:

if (Datadog.isInitialized()) {
    // your code here
}

Debugging

When writing your application, you can enable development logs by calling the setVerbosity method. All internal messages in the library with a priority equal to or higher than the provided level are then logged to Android's Logcat:

Datadog.setVerbosity(Log.INFO)

RUM Debug Widget

The RUM Debug Widget provides a floating overlay that displays key metrics such as memory usage, CPU load, and RUM events in real time. It is intended for debugging and development purposes only.

See the module README for setup instructions.

Migrating to 3.0.0

If you've been using the SDK v2 or SDK v1, there are some breaking changes introduced in version 3.0.0. See the migration guide for more information.

"Deobfuscation failed" warning

A warning appears when deobfuscation fails for a stack trace. If the stack trace is not obfuscated to begin with, you can ignore this warning. Otherwise, use the RUM Debug Symbols page to view all your uploaded mapping files. See Investigate Obfuscated Stack Traces with RUM Debug Symbols.

Overview

If you experience unexpected behavior with Datadog RUM, use this guide to resolve issues. If you continue to have trouble, contact Datadog Support for further assistance.

Check if Datadog SDK is properly initialized

After you configure Datadog SDK and run the app for the first time, check your debugger console in Xcode. The SDK implements several consistency checks and outputs relevant warnings if something is misconfigured.

Debugging

When writing your application, you can enable development logs by setting the verbosityLevel value. Relevant messages from the SDK with a priority equal to or higher than the provided level are output to the debugger console in Xcode:

Datadog.verbosityLevel = .debug

You should then see output similar to the following, indicating that a batch of RUM data was properly uploaded:

[DATADOG SDK] 🐶 → 17:23:09.849 [DEBUG] ⏳ (rum) Uploading batch...
[DATADOG SDK] 🐶 → 17:23:10.972 [DEBUG]    → (rum) accepted, won't be retransmitted: success

Recommendation: Use Datadog.verbosityLevel in the DEBUG configuration, and unset it in RELEASE.

"Deobfuscation failed" warning

A warning appears when deobfuscation fails for a stack trace. If the stack trace is not obfuscated to begin with, you can ignore this warning. Otherwise, use the RUM Debug Symbols page to view all your uploaded dSYMs. See Investigate Obfuscated Stack Traces with RUM Debug Symbols.

Overview

If you experience unexpected behavior with Datadog RUM, use this guide to resolve issues. If you continue to have trouble, contact Datadog Support for further assistance.

Duplicate interface (iOS)

If you see this error while building iOS after upgrading to datadog_flutter_plugin v2.0:

Semantic Issue (Xcode): Duplicate interface definition for class 'DatadogSdkPlugin'
/Users/exampleuser/Projects/test_app/build/ios/Debug-iphonesimulator/datadog_flutter_plugin/datadog_flutter_plugin.framework/Headers/DatadogSdkPlugin.h:6:0

Try performing flutter clean && flutter pub get and rebuilding. This usually resolves the issue.

Duplicate classes (Android)

If you see this error while building Android after the upgrading to datadog_flutter_plugin v2.0:

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':app:checkDebugDuplicateClasses'.
> A failure occurred while executing com.android.build.gradle.internal.tasks.CheckDuplicatesRunnable

Make sure that you've updated your version of Kotlin to at least 1.8 in your build.gradle file.

CocoaPods issues

If you have trouble building your iOS application after adding the Datadog SDK because of errors being thrown by CocoaPods, check which error you are getting. The most common error is an issue getting the most up-to-date native library from CocoaPods, which can be solved by running the following in your ios directory:

pod install --repo-update

Another common error is an issue loading the FFI library on Apple Silicon Macs. If you see an error similar to the following:

LoadError - dlsym(0x7fbbeb6837d0, Init_ffi_c): symbol not found - /Library/Ruby/Gems/2.6.0/gems/ffi-1.13.1/lib/ffi_c.bundle
/System/Library/Frameworks/Ruby.framework/Versions/2.6/usr/lib/ruby/2.6.0/rubygems/core_ext/kernel_require.rb:54:in `require'
/System/Library/Frameworks/Ruby.framework/Versions/2.6/usr/lib/ruby/2.6.0/rubygems/core_ext/kernel_require.rb:54:in `require'
/Library/Ruby/Gems/2.6.0/gems/ffi-1.13.1/lib/ffi.rb:6:in `rescue in <top (required)>'
/Library/Ruby/Gems/2.6.0/gems/ffi-1.13.1/lib/ffi.rb:3:in `<top (required)>'

Follow the instructions in the Flutter documentation for working with Flutter on Apple Silicon.

Undefined symbol (iOS)

If you use Flutter's build ios-framework command, you may see errors similar to the following:

Undefined symbol: _OBJC_CLASS_$_PLCrashReport
Undefined symbol: _OBJC_CLASS_$_PLCrashReportBinaryImageInfo
Undefined symbol: _OBJC_CLASS_$_PLCrashReportStackFrameInfo
...

This occurs because the build ios-framework command does not properly include PLCrashReporter, which the Datadog Flutter SDK depends on. To resolve this issue, Datadog recommends manually including the PLCrashReporter dependency. The framework and instructions for including it are available on its GitHub page.

Set sdkVerbosity

If you're able to run your app, but you are not seeing the data you expect on the Datadog site, try adding the following to your code before calling DatadogSdk.initialize:

DatadogSdk.instance.sdkVerbosity = CoreLoggerLevel.debug;

This causes the SDK to output additional information about what it's doing and what errors it's encountering, which may help you and Datadog Support narrow down your issue.

Not seeing errors

If you do not see any errors in RUM, it's likely no view has been started. Make sure you have started a view with DatadogSdk.instance.rum?.startView or, if you are using DatadogRouteObserver make sure your current Route has a name.

Issues with automatic resource tracking and distributed tracing

The Datadog tracking HTTP client package works with most common Flutter networking packages that rely on dart:io, including http and Dio.

If you are seeing resources in your RUM Sessions, then the tracking HTTP client is working, but other steps may be required to use distributed tracing.

By default, the Datadog RUM Flutter SDK samples distributed traces at only 20% of resource requests. While determining if there is an issue with your setup, you should set this value to 100% of traces by modifying your initialization with the following lines:

final configuration = DdSdkConfiguration(
   //
   rumConfiguration: DatadogRumConfiguration(
    applicationId: '<RUM_APPLICATION_ID>',
    tracingSamplingRate: 100.0
   ),
);

If you are still having issues, check that your firstPartyHosts property is set correctly. These should be hosts only, without schemas or paths, and they do not support regular expressions or wildcards. For example:

✅ Good - 'example.com', 'api.example.com', 'us1.api.sample.com' ❌ Bad - 'https://example.com', '.example.com', 'us1.sample.com/api/', 'api.sample.com/api'

"Deobfuscation failed" warning

A warning appears when deobfuscation fails for a stack trace. If the stack trace is not obfuscated to begin with, you can ignore this warning. Otherwise, use the RUM Debug Symbols page to view all your uploaded symbol files, dSYMs, and mapping files. See Investigate Obfuscated Stack Traces with RUM Debug Symbols.

Overview

If you experience unexpected behavior with Datadog React Native RUM, use this guide to resolve issues. If you continue to have trouble, contact Datadog Support for further assistance.

No data is being sent to Datadog

Follow these instructions in order when the SDK has been installed and the app compiles, but no data is received by Datadog.

Check the configuration

Sometimes, no data is sent due to a small misstep in the configuration.

Here are some common things to check for:

• Make sure your clientToken and applicationId are correct.
• Make sure you have not set sessionSamplingRate to something other than 100 (100 is the default value), or else your session might not be sent.
• If you've set up a Proxy in the Datadog configuration, check that it has been correctly configured.
• Check that you are tracking views (all events must be attached to a view) and sending events.

Review SDK logs in React Native

• Set config.verbosity = SdkVerbosity.DEBUG, which imports SdkVerbosity from @datadog/mobile-react-native.

• Logs start appearing in the JavaScript console, like the following output:

  Copy

  INFO  DATADOG: Datadog SDK was initialized
  INFO  DATADOG: Datadog SDK is tracking interactions
  INFO  DATADOG: Datadog SDK is tracking XHR resources
  INFO  DATADOG: Datadog SDK is tracking errors
  DEBUG  DATADOG: Starting RUM View "Products" #Products-oaZlP_FVwGM5vtPoup_rT
  DEBUG  DATADOG: Adding RUM Action "RCTView" (TAP)
  

  Note: In this example, the first four logs indicate that the SDK has been correctly configured and the last two lines are events that were sent.

Possible cause

If you are on iOS and see some DEBUG logs indicating that logs or RUM events were sent before the initialization logs, this may be why the SDK is not sending events.

You cannot send events before initialization, and attempting to do so puts the SDK in a state where it cannot send any data.

Solution

Review native logs

Reviewing native logs can give you more input on what could be going wrong.

On iOS

• Open your project in Xcode by running xed ios.

• Build your project for a simulator or a device.

• Native logs start appearing on the bottom right corner:

You can filter logs by "DATADOG" and look for any error.

If you are indeed sending events, you should see the following logs:

[DATADOG SDK] 🐶 → 10:02:47.398 [DEBUG] ⏳ (rum) Uploading batch...
[DATADOG SDK] 🐶 → 10:02:47.538 [DEBUG]    → (rum) accepted, won't be retransmitted: [response code: 202 (accepted), request ID: AAAABBBB-1111-2222-3333-777788883333]

The first log indicates that some data is being sent, and the second log indicates that the data has been received.

Possible cause

If you see the log below, it means that you have called a RUM method before initializing the SDK.

[DATADOG SDK] 🐶 → 10:09:13.621 [WARN] The `Global.rum` was called but no `RUMMonitor` is registered. Configure and register the RUM Monitor globally before invoking the feature:

Solution

On Android

• For a better debugging experience, Datadog recommends installing pidcat.

  • pidcat filters the device logs (obtained by adb logcat) to only show the one from your application.
  • See this issue for M1 users who don't have Python 2.

• Modify node_modules/@datadog/mobile-react-native/android/src/main/kotlin/com/datadog/reactnative/DdSdk.kt to enable verbose logging from the native SDK:

  Copy

  fun initialize(configuration: ReadableMap, promise: Promise) {
      // ...
  
      datadog.initialize(appContext, credentials, nativeConfiguration, trackingConsent)
      datadog.setVerbosity(Log.VERBOSE) // Add this line
  
      // ...
  }
  

• Run the app on a phone connected in debug mode to your laptop (should appear when running adb devices), or from an emulator.

• Run pidcat my.app.package.name or adb logcat from your laptop.

• Look for any error mentioning Datadog.

Pidcat output looks like this:

In this example, the last log indicates that the batch of RUM data was sent successfully.

Undefined symbols: Swift

If you see the following error message:

Undefined symbols for architecture x86_64:
  "static Foundation.JSONEncoder.OutputFormatting.withoutEscapingSlashes.getter : Foundation.JSONEncoder.OutputFormatting", referenced from:
      static (extension in Datadog):Foundation.JSONEncoder.default() -> Foundation.JSONEncoder in libDatadogSDK.a(JSONEncoder.o)
...

Open Xcode, go to the Build Settings of your project (not your app target), and make sure Library Search Paths have the following settings:

LIBRARY_SEARCH_PATHS = (
  "\"$(TOOLCHAIN_DIR)/usr/lib/swift/$(PLATFORM_NAME)\"",
  "\"/usr/lib/swift\"",
  "\"$(inherited)\"",
);

Undefined symbols: _RCTModule

If you see an undefined _RCTModule symbol, it may be related to this change in the react-native v0.63 changelog.

You can make the following change to fix it:

// DdSdk.m
// instead of
#import <React/RCTBridgeModule.h>
// maybe that:
@import React // or @import React-Core

Infinite loop-like error messages

If you run into an issue where your React Native project displays a stream of error messages and significantly raises your CPU usage, try creating a new React Native project.

Android build failures with SDK version 2.*

Unable to make field private final java.lang.String java.io.File.path accessible

If your Android build fails with an error like:

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':app:processReleaseMainManifest'.
> Unable to make field private final java.lang.String java.io.File.path accessible: module java.base does not "opens java.io" to unnamed module @1bbf7f0e

You are using Java 17, which is not compatible with your React Native version. Switch to Java 11 to solve the issue.

java.lang.UnsupportedClassVersionError

If your Android build fails with an error like:

java.lang.UnsupportedClassVersionError: com/datadog/android/lint/DatadogIssueRegistry has been compiled by a more recent version of the Java Runtime (class file version 61.0), this version of the Java Runtime only recognizes class file versions up to 55.0

You are using a version of Java that is too old. Switch to Java 17 to solve the issue.

Unsupported class file major version 61

If your Android build fails with an error like:

FAILURE: Build failed with an exception.

* What went wrong:
Could not determine the dependencies of task ':app:lintVitalRelease'.
> Could not resolve all artifacts for configuration ':app:debugRuntimeClasspath'.
   > Failed to transform dd-sdk-android-core-2.0.0.aar (com.datadoghq:dd-sdk-android-core:2.0.0) to match attributes {artifactType=android-manifest, org.gradle.category=library, org.gradle.dependency.bundling=external, org.gradle.libraryelements=aar, org.gradle.status=release, org.gradle.usage=java-runtime}.
      > Execution failed for JetifyTransform: /Users/me/.gradle/caches/modules-2/files-2.1/com.datadoghq/dd-sdk-android-core/2.0.0/a97f8a1537da1de99a86adf32c307198b477971f/dd-sdk-android-core-2.0.0.aar.
         > Failed to transform '/Users/me/.gradle/caches/modules-2/files-2.1/com.datadoghq/dd-sdk-android-core/2.0.0/a97f8a1537da1de99a86adf32c307198b477971f/dd-sdk-android-core-2.0.0.aar' using Jetifier. Reason: IllegalArgumentException, message: Unsupported class file major version 61. (Run with --stacktrace for more details.)

You are using a version of Android Gradle Plugin below 5.0. To fix the issue, add in your android/gradle.properties file:

android.jetifier.ignorelist=dd-sdk-android-core

Duplicate class kotlin.collections.jdk8.*

If your Android build fails with an error like:

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':app:checkReleaseDuplicateClasses'.
> A failure occurred while executing com.android.build.gradle.internal.tasks.CheckDuplicatesRunnable
   > Duplicate class kotlin.collections.jdk8.CollectionsJDK8Kt found in modules jetified-kotlin-stdlib-1.8.10 (org.jetbrains.kotlin:kotlin-stdlib:1.8.10) and jetified-kotlin-stdlib-jdk8-1.7.20 (org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.7.20)
     Duplicate class kotlin.internal.jdk7.JDK7PlatformImplementations found in modules jetified-kotlin-stdlib-1.8.10 (org.jetbrains.kotlin:kotlin-stdlib:1.8.10) and jetified-kotlin-stdlib-jdk7-1.7.20 (org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.7.20)

You need to set a Kotlin version for your project to avoid clashes among Kotlin dependencies. In your android/build.gradle file, specify the kotlinVersion:

buildscript {
    ext {
        // targetSdkVersion = ...
        kotlinVersion = "1.8.21"
    }
}

Alternatively, you can add the following rules to your build script in your android/app/build.gradle file:

dependencies {
    constraints {
        implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.8.21") {
            because("kotlin-stdlib-jdk7 is now a part of kotlin-stdlib")
        }
        implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.8.21") {
            because("kotlin-stdlib-jdk8 is now a part of kotlin-stdlib")
        }
    }
}

"Deobfuscation failed" warning

A warning appears when deobfuscation fails for a stack trace. If the stack trace is not obfuscated to begin with, you can ignore this warning. Otherwise, use the RUM Debug Symbols page to view all your uploaded source maps, dSYMs, and mapping files. See Investigate Obfuscated Stack Traces with RUM Debug Symbols.

Overview

If you experience unexpected behavior with the Datadog Kotlin Multiplatform SDK, use this guide to resolve issues. If you continue to have trouble, contact Datadog Support for further assistance.

Check if Datadog RUM is initialized

Use the utility method isInitialized to check if the SDK is properly initialized:

if (Datadog.isInitialized()) {
    // your code here
}

Debugging

When writing your application, you can enable development logs by calling the setVerbosity method. All internal messages in the library with a priority equal to or higher than the provided level are then logged either to Android's Logcat or to the debugger console in Xcode:

Datadog.setVerbosity(SdkLogVerbosity.DEBUG)

Set tracking consent (GDPR compliance)

To be compliant with GDPR, the SDK requires the tracking consent value at initialization. Tracking consent can be one of the following values:

• TrackingConsent.PENDING: (Default) The SDK starts collecting and batching the data but does not send it to the collection endpoint. The SDK waits for the new tracking consent value to decide what to do with the batched data.
• TrackingConsent.GRANTED: The SDK starts collecting the data and sends it to the data collection endpoint.
• TrackingConsent.NOT_GRANTED: The SDK does not collect any data. You are not able to manually send any logs, traces, or RUM events.

To update the tracking consent after the SDK is initialized, call Datadog.setTrackingConsent(<NEW CONSENT>). The SDK changes its behavior according to the new consent. For example, if the current tracking consent is TrackingConsent.PENDING and you update it to:

• TrackingConsent.GRANTED: The SDK sends all current batched data and future data directly to the data collection endpoint.
• TrackingConsent.NOT_GRANTED: The SDK wipes all batched data and does not collect any future data.

Common problems

iOS binary linking

Missing PLCrashReporter symbols

If there is an error during the linking step about missing PLCrashReporter symbols in the linker search paths, like the following:

Undefined symbols for architecture arm64:
  "_OBJC_CLASS_$_PLCrashReport", referenced from:
       in DatadogCrashReporting[arm64][15](PLCrashReporterIntegration.o)
  "_OBJC_CLASS_$_PLCrashReportBinaryImageInfo", referenced from:
       in DatadogCrashReporting[arm64][7](CrashReport.o)
  "_OBJC_CLASS_$_PLCrashReportStackFrameInfo", referenced from:
       in DatadogCrashReporting[arm64][7](CrashReport.o)
  "_OBJC_CLASS_$_PLCrashReportThreadInfo", referenced from:
       in DatadogCrashReporting[arm64][7](CrashReport.o)
  "_OBJC_CLASS_$_PLCrashReporter", referenced from:
       in DatadogCrashReporting[arm64][15](PLCrashReporterIntegration.o)
  "_OBJC_CLASS_$_PLCrashReporterConfig", referenced from:
       in DatadogCrashReporting[arm64][15](PLCrashReporterIntegration.o)

Then you need to explicitly pass the CrashReporter framework name to the linker:

targets.withType(KotlinNativeTarget::class.java) {
   compilations.getByName("main").compileTaskProvider {
       compilerOptions {
           freeCompilerArgs.addAll(
               listOf(
                  "-linker-option",
                  "-framework CrashReporter"
               )
           )
       }
   }
}

Missing swiftCompatibility symbols

If there is an error during the linking step about missing swiftCompatibility symbols in the linker search paths, like the following:

Undefined symbols for architecture arm64:
  "__swift_FORCE_LOAD_$_swiftCompatibility56", referenced from:
      __swift_FORCE_LOAD_$_swiftCompatibility56_$_DatadogCrashReporting in DatadogCrashReporting[arm64][4](BacktraceReporter.o)
  "__swift_FORCE_LOAD_$_swiftCompatibilityConcurrency", referenced from:
      __swift_FORCE_LOAD_$_swiftCompatibilityConcurrency_$_DatadogCrashReporting in DatadogCrashReporting[arm64][4](BacktraceReporter.o)

Then you can suppress this error:

targets.withType(KotlinNativeTarget::class.java) {
   compilations.getByName("main").compileTaskProvider {
       compilerOptions {
           freeCompilerArgs.addAll(
               listOf(
                  "-linker-option",
                  "-U __swift_FORCE_LOAD_\$_swiftCompatibility56",
                  "-linker-option",
                  "-U __swift_FORCE_LOAD_\$_swiftCompatibilityConcurrency"
               )
           )
       }
   }
}

Overview

If you experience unexpected behavior with the Datadog C++ SDK, use this guide to resolve issues. If you continue to have trouble, contact Datadog Support for further assistance.

Enable diagnostic logging

The SDK outputs Warning and Error messages to stderr by default. To see more verbose output during development, lower the diagnostic threshold on your CoreConfig before creating the core:

datadog::CoreConfig config("<client_token>", "<service_name>", "<environment>");
config.SetDiagnosticThreshold(datadog::DiagnosticLevel::Debug);

auto core = datadog::Core::Create(config, datadog::TrackingConsent::Granted);

You should see output similar to the following when data is successfully uploaded:

[DATADOG STATUS] Upload cycle finished with all uploads successful

Recommendation: Remove the SetDiagnosticThreshold call in production builds to revert to the default (Warning) and avoid unnecessary log volume.

To route diagnostic output somewhere other than stderr, supply a custom handler. The msg.text pointer is only valid for the duration of the call, so copy the string if you need to store it:

config.SetDiagnosticHandler([](const datadog::DiagnosticMessage& msg) {
    my_logger.write(msg.text);
});

Pass nullptr to SetDiagnosticHandler to suppress all diagnostic output entirely.

Runtime Issues

No data appears in Datadog

If your application runs but data does not appear in the Datadog UI, check the following:

1. Tracking consent: Confirm that tracking consent is set to Granted. If the core was initialized with Pending or NotGranted, no data is uploaded.
2. Start() was called: The SDK does not collect or upload data until core->Start() is called after all features are registered.
3. Active view: RUM errors, resources, and actions are attached to the active view. If no view has been started with StartView(), those events may be dropped. Start a view before recording other events.
4. Network connectivity: The SDK requires outbound HTTPS access to Datadog intake endpoints on port 443. Verify that your network allows these connections.
5. Diagnostic output: Lower the diagnostic threshold (see above) and look for messages indicating upload failures or configuration errors.

Storage directory is not writable

If diagnostic output shows storage errors, verify that the storage directory exists and is writable by the application process. The SDK uses the directory set with SetApplicationStoragePath(), or the current working directory by default.

Crash reports are not appearing after a crash

Crash reports are uploaded on the next application launch after the crash, not immediately (since the process is terminated at crash time). After triggering a test crash, relaunch the application and wait for the upload to complete.

If reports still do not appear:

• Confirm that CrashReporting::Register() is called after creating the core but before core->Start().
• Verify that the application has write access to its storage directory.
• Check that the crashpad_handler executable is present in the same directory as your application binary (if using Crashpad mode). Use datadog_enable(your_target) in CMake to copy it automatically.

Overview

If you encounter issues while using the Datadog .NET MAUI SDK, check the open issues on GitHub for known problems and solutions. If you continue to have trouble, contact Datadog Support for further assistance.

Enable verbose SDK logging

You can enable verbose SDK logging to help diagnose issues. Set Verbosity on the SDK configuration — all internal messages at or above the provided level are written to Logcat (Android) and to the Xcode debugger console (iOS):

using Datadog.Maui;
using Datadog.Maui.Configuration;

DdSdk.Initialize(new DdSdkConfiguration
{
    ClientToken = "<CLIENT_TOKEN>",
    Environment = "<ENV_NAME>",
    TrackingConsent = TrackingConsent.Granted,
    Verbosity = SdkVerbosity.DEBUG,
});

Supported levels: DEBUG, INFO, WARN, ERROR. The same property can be set via JSON (File-based configuration):

{ "Verbosity": "DEBUG" }

Enable verbose logging only while diagnosing — the additional log volume can affect application performance on debug devices.

No RUM events appear in Datadog

Work through the checks below in order.

1. Confirm the SDK is initialized

DdSdk.Initialize (Pattern 2) and .UseDatadog(...) (Pattern 1) must run before any other Datadog API call. If you initialize from a non-default location (for example, a feature flag–gated startup path), make sure that code runs on every cold launch.

With verbose logging enabled, the SDK prints a startup message confirming the active site, environment, and feature set.

2. Confirm tracking consent is Granted

If TrackingConsent is Pending or NotGranted, the SDK does not send any data. Update the consent at runtime after the user accepts your privacy dialog:

DdSdk.SetTrackingConsent(TrackingConsent.Granted);

See Set tracking consent (GDPR compliance) for the full state machine.

3. Confirm the right Datadog site

The default site is Us1. If your organization is on a different site (Us3, Us5, Eu1, Ap1, Ap2, Us1Fed), set Site accordingly on DdSdkConfiguration. The site selector at the top of these documentation pages updates code samples to match.

4. Confirm the application ID and client token

A wrong application ID silently drops events server-side. Double-check the values against the application you created in Digital Experience > Add an Application.

Events appear, but stack traces are not symbolicated

For native iOS and Android crashes, dSYMs (iOS) and mapping.txt (Android) must be uploaded to Datadog. See Get deobfuscated stack traces for the full pipeline.

For managed C# stack traces, Portable PDB files must be bundled in the published app. See Bundle Portable PDB files for C# stack traces.

C# errors and native crashes appear twice

When NativeCrashReportEnabled = true, an unhandled C# exception that crashes the app is reported both as a managed C# error (via AppDomain.UnhandledException) and as a native crash (via the platform crash reporter). This is intentional — the two events share a session and view so you can correlate them. To keep only one, filter with ErrorEventMapper.

Automatic actions are bucketed under the wrong view

TapGestureRecognizer.Tapped and SwipeGestureRecognizer.Swiped only fire on completion, so a tap or swipe that triggers a navigation is recorded against the destination view rather than the source. This is a known limitation that affects only Views with explicit gesture recognizers; Button and ImageButton taps are not affected. See Known limitation: gesture-driven navigation.

View attributes attach to the wrong view

DdRum.AddViewAttribute runs against the view that is active in the SDK at the time of the call. If you call it from a page constructor or OnAppearing, the SDK has not yet called StartView for the new page, and the attribute lands on the previous view.

Call AddViewAttribute from OnNavigatedTo instead — by then the SDK has started the destination view. See Add view attributes.

dotnet publish finishes but symbols are not uploaded

The MSBuild target skips silently when datadog-ci is missing or DATADOG_API_KEY is unset. The terminal logger hides those messages by default — add -v n -tl:off to dotnet publish to see them:

dotnet publish -c Release -f net10.0-ios -r ios-arm64 \
  -p:DatadogUploadSymbols=true -v n -tl:off

See Symbol upload troubleshooting for the full diagnostic list.

Overview

If you experience unexpected behavior with the Datadog Roku SDK, use this guide to resolve issues. If you continue to have trouble, contact Datadog Support for further assistance.

SDK not sending data to Datadog

If your channel is running but no data appears in Datadog, verify that the site parameter in your initialization matches the datacenter for your Datadog organization:

datadogroku_initialize({
    clientToken: "<CLIENT_TOKEN>",
    applicationId: "<APPLICATION_ID>",
    site: "datadoghq.com", ' Update this value to match your organization's datacenter
    env: "<ENV_NAME>",
    sessionSampleRate: 100,
    launchArgs: args
})

The default value (datadoghq.com) routes data to the US1 datacenter. If your organization is on EU1, AP1, or another region, update this value accordingly. See the Roku Channel Monitoring Setup for the correct site value for your region.

Overview

If you experience unexpected behavior with Datadog RUM, use this guide to resolve issues. If you continue to have trouble, contact Datadog Support for further assistance.

Set sdkVerbosity for easier debugging

If you're able to run your app, but you are not seeing the data you expect on the Datadog site, try adding the following to your code as part of initialization:

DatadogSdk.Instance.SetSdkVerbosity(CoreLoggerLevel.Debug);

This causes the SDK to output additional information about what it's doing and what errors it's encountering, which may help you and Datadog Support narrow down your issue.

The SDK is not sending data

If you're not seeing any data in Datadog:

1. Make sure you are running your app on an iOS or Android simulator, emulator, or device, and not from the editor.

2. Check that you have set the TrackingConsent as part of your initialization. Tracking consent is set to TrackingConsent.Pending during initialization, and needs to be set to TrackingConsent.Granted before Datadog sends any information.

   Copy

   DatadogSdk.Instance.SetTrackingConsent(TrackingConsent.Granted);