From a1f6f44c2ed7272bb39a328157a2c32313652394 Mon Sep 17 00:00:00 2001 From: Ida Adjivon Date: Thu, 9 Oct 2025 14:31:57 -0400 Subject: [PATCH 1/5] added first three steps to the ET kotlin doc --- .../frontend/mobile/kotlin-multiplatform.md | 207 +++++++++++++++++- 1 file changed, 206 insertions(+), 1 deletion(-) diff --git a/content/en/error_tracking/frontend/mobile/kotlin-multiplatform.md b/content/en/error_tracking/frontend/mobile/kotlin-multiplatform.md index 96af0e081286e..aecfddb0914f1 100644 --- a/content/en/error_tracking/frontend/mobile/kotlin-multiplatform.md +++ b/content/en/error_tracking/frontend/mobile/kotlin-multiplatform.md @@ -5,4 +5,209 @@ code_lang: kotlin-multiplatform code_lang_weight: 50 --- -{{< include-markdown "real_user_monitoring/error_tracking/mobile/kotlin-multiplatform" >}} \ No newline at end of file +## Overview + +Error Tracking processes errors collected from the Kotlin Multiplatform SDK. + +Enable Kotlin Multiplatform Crash Reporting and Error Tracking to get comprehensive crash reports and error trends. With this feature, you can access: + +- Aggregated Kotlin Multiplatform crash dashboards and attributes +- Deobfuscated Kotlin Multiplatform (iOS and Android) crash reports +- Trend analysis with Kotlin Multiplatform error tracking + +Your crash reports appear in [**Error Tracking**][1]. + +## Setup + +If you have not set up the Kotlin Multiplatform SDK yet, follow the [in-app setup instructions][2] or see the [Kotlin Multiplatform setup documentation][3]. Then, follow the steps on this page to enable React Native Crash Reporting and Error Tracking. + +**Note**: For any given error, you can access the file path, line number, and a code snippet for each frame of the related stack trace. + + +### Step 1 - Declare the Kotlin Multiplatform SDK as a dependency + +Declare [`dd-sdk-kotlin-multiplatform-rum`][301] as a common source set dependency in your Kotlin Multiplatform module's `build.gradle.kts` file. + +```kotlin +kotlin { + // declare targets + // ... + + sourceSets { + // ... + commonMain.dependencies { + implementation("com.datadoghq:dd-sdk-kotlin-multiplatform-rum:") + } + } +} +``` + +### Step 2 - Add native dependencies + +{{< tabs >}} +{{% tab "Android" %}} +All uncaught exceptions and ANRs resulting in a crash are reported by the Kotlin Multiplatform SDK (see [limitations](#limitations)). On top of these crashes, you can configure the SDK to report NDK crashes, and control the reporting of non-fatal ANRs. + +#### Add NDK crash reporting + +Your Android application may be running native code (C/C++) for performance or code reusability. To enable NDK crash reporting, use the Datadog NDK library. + +1. Add the Gradle dependency to your Android source set by declaring the library as a dependency in your `build.gradle.kts` file: + +```kotlin +kotlin { + sourceSets { + androidMain.dependencies { + implementation("com.datadoghq:dd-sdk-android-ndk:x.x.x") + } + } +} +``` + +2. Enable NDK crash collection after initializing the SDK. + +``` kotlin +// in Android source set +NdkCrashReports.enable() +``` + +An "Application Not Responding" ([ANR][4]) is an Android-specific type of error that gets triggered when the application is unresponsive for too long. + +For any Android version, you can override the default setting for reporting non-fatal ANRs by setting `trackNonFatalAnrs` (available from Android source set only) to `true` or `false` when initializing the SDK. + +ANRs are only reported through RUM (not through logs). For more information, see [Android Crash Reporting and Error Tracking - Add ANR Reporting][5]. + + +[4]: https://developer.android.com/topic/performance/vitals/anr +[5]: /real_user_monitoring/error_tracking/mobile/android/#add-anr-reporting + +{{% /tab %}} + +{{% tab "iOS" %}} + +**Note**: Kotlin 2.0.20 or higher is required if crash tracking is enabled on iOS. Otherwise, due to the compatibility with `PLCrashReporter`, the application may hang if crash tracking is enabled. + +All uncaught exceptions resulting in a crash are reported by the Kotlin Multiplatform SDK. + + +Add the following Datadog iOS SDK dependencies, which are needed for the linking step: + +* `DatadogObjc` +* `DatadogCrashReporting` + +**Note**: Versions of these dependencies should be aligned with the version used by the Datadog Kotlin Multiplatform SDK itself. You can find the complete mapping of iOS SDK versions for each Kotlin Multiplatform SDK release in the [version compatibility guide][501]. + + +#### Adding native iOS dependencies using the CocoaPods plugin + +If you are using Kotlin Multiplatform library as a CocoaPods dependency for your iOS application, you can add dependencies as following: + +```kotlin +cocoapods { + // ... + + framework { + baseName = "sharedLib" + } + + pod("DatadogObjc") { + linkOnly = true + version = x.x.x + } + + pod("DatadogCrashReporting") { + linkOnly = true + version = x.x.x + } +} +``` + +#### Adding native iOS dependencies using Xcode + +If you are integrating Kotlin Multiplatform library as a framework with an `embedAndSignAppleFrameworkForXcode` Gradle task as a part of your Xcode build, you can add the necessary dependencies directly in Xcode as following: + +1. Click on your project in Xcode and go to the **Package Dependencies** tab. +2. Add the iOS SDK package dependency by adding `https://github.com/DataDog/dd-sdk-ios.git` as a package URL. +3. Select the version from the table above. +4. Click on the necessary application target and open the **General** tab. +5. Scroll down to the **Frameworks, Libraries, and Embedded Content** section and add the dependencies mentioned above. + +#### Add app hang reporting + +App hangs are an iOS-specific type of error that happens when the application is unresponsive for too long. + +By default, app hangs reporting is **disabled**, but you can enable it and set your own threshold to monitor app hangs that last more than a specified duration by using the `setAppHangThreshold` (available from iOS source set only) initialization method. + +App hangs are only reported through RUM (not through logs). For more information, see [iOS Crash Reporting and Error Tracking - Add ANR Reporting][6]. + + +[501]: https://github.com/DataDog/dd-sdk-kotlin-multiplatform/blob/develop/NATIVE_SDK_VERSIONS.md +[6]: /real_user_monitoring/error_tracking/mobile/ios/#add-app-hang-reporting +{{% /tab %}} +{{< /tabs >}} + + + +### Step 3 - Specify application details in the UI + +1. Navigate to [**Digital Experience** > **Add an Application**][601]. +2. Select `Kotlin Multiplatform` as the application type and enter an application name to generate a unique Datadog application ID and client token. +3. To disable automatic user data collection for either client IP or geolocation data, uncheck the boxes for those settings. For more information, see [RUM Kotlin Multiplatform Data Collected][602]. + +To ensure the safety of your data, you must use a client token. If you use only [Datadog API keys][603] to configure the Datadog SDK, they are exposed client-side in the Android application's APK byte code. + +For more information about setting up a client token, see the [Client Token documentation][604]. + + + + + + + + + + + + +## Further Reading + +{{< partial name="whats-next/whats-next.html" >}} + +[1]: https://app.datadoghq.com/rum/error-tracking +[2]: https://app.datadoghq.com/rum/application/create +[3]: /real_user_monitoring/application_monitoring/kotlin_multiplatform/setup +[301]: https://github.com/DataDog/dd-sdk-kotlin-multiplatform/tree/develop/features/rum +[4]: https://developer.android.com/topic/performance/vitals/anr +[5]: /real_user_monitoring/error_tracking/mobile/android/#add-anr-reporting +[501]: https://github.com/DataDog/dd-sdk-kotlin-multiplatform/blob/develop/NATIVE_SDK_VERSIONS.md +[6]: /real_user_monitoring/error_tracking/mobile/ios/#add-app-hang-reporting +[601]: https://app.datadoghq.com/error-tracking/settings/setup/client +[602]: /real_user_monitoring/kotlin_multiplatform/data_collected/ +[603]: /account_management/api-app-keys/#api-keys +[604]: /account_management/api-app-keys/#client-tokens + + + + + \ No newline at end of file From 8d78fbbe93c91611a6258d47b5832bdee7396c58 Mon Sep 17 00:00:00 2001 From: Ida Adjivon Date: Thu, 9 Oct 2025 17:01:24 -0400 Subject: [PATCH 2/5] added the ET content to the ET page --- .../frontend/mobile/kotlin-multiplatform.md | 240 +++++++++++++++++- 1 file changed, 233 insertions(+), 7 deletions(-) diff --git a/content/en/error_tracking/frontend/mobile/kotlin-multiplatform.md b/content/en/error_tracking/frontend/mobile/kotlin-multiplatform.md index aecfddb0914f1..084f6bb25ceaa 100644 --- a/content/en/error_tracking/frontend/mobile/kotlin-multiplatform.md +++ b/content/en/error_tracking/frontend/mobile/kotlin-multiplatform.md @@ -85,7 +85,7 @@ ANRs are only reported through RUM (not through logs). For more information, see {{% tab "iOS" %}} -**Note**: Kotlin 2.0.20 or higher is required if crash tracking is enabled on iOS. Otherwise, due to the compatibility with `PLCrashReporter`, the application may hang if crash tracking is enabled. +Kotlin 2.0.20 or higher is required if crash tracking is enabled on iOS. Otherwise, due to the compatibility with `PLCrashReporter`, the application may hang if crash tracking is enabled. All uncaught exceptions resulting in a crash are reported by the Kotlin Multiplatform SDK. @@ -160,14 +160,239 @@ For more information about setting up a client token, see the [Client Token docu +### step 4 - Initialize Datadog SDK +In the initialization snippet, set an environment name. For Android, set a variant name if it exists. For more information, see [Using Tags][701]. +See [`trackingConsent`](#set-tracking-consent-gdpr-compliance) to add GDPR compliance for your EU users, and [other configuration options][702] to initialize the library. +{{< site-region region="us" >}} +```kotlin +// in common source set +fun initializeDatadog(context: Any? = null) { + // context should be application context on Android and can be null on iOS + val appClientToken = + val appEnvironment = + val appVariantName = + + val configuration = Configuration.Builder( + clientToken = appClientToken, + env = appEnvironment, + variant = appVariantName + ) + .trackCrashes(true) + .build() + + Datadog.initialize(context, configuration, trackingConsent) +} +``` +{{< /site-region >}} + +{{< site-region region="eu" >}} +```kotlin +// in common source set +fun initializeDatadog(context: Any? = null) { + // context should be application context on Android and can be null on iOS + val appClientToken = + val appEnvironment = + val appVariantName = + + val configuration = Configuration.Builder( + clientToken = appClientToken, + env = appEnvironment, + variant = appVariantName + ) + .useSite(DatadogSite.EU1) + .trackCrashes(true) + .build() + + Datadog.initialize(context, configuration, trackingConsent) +} +``` +{{< /site-region >}} + +{{< site-region region="us3" >}} +```kotlin +// in common source set +fun initializeDatadog(context: Any? = null) { + // context should be application context on Android and can be null on iOS + val appClientToken = + val appEnvironment = + val appVariantName = + + val configuration = Configuration.Builder( + clientToken = appClientToken, + env = appEnvironment, + variant = appVariantName + ) + .useSite(DatadogSite.US3) + .trackCrashes(true) + .build() + + Datadog.initialize(context, configuration, trackingConsent) +} +``` +{{< /site-region >}} + +{{< site-region region="us5" >}} +```kotlin +// in common source set +fun initializeDatadog(context: Any? = null) { + // context should be application context on Android and can be null on iOS + val appClientToken = + val appEnvironment = + val appVariantName = + + val configuration = Configuration.Builder( + clientToken = appClientToken, + env = appEnvironment, + variant = appVariantName + ) + .useSite(DatadogSite.US5) + .trackCrashes(true) + .build() + + Datadog.initialize(context, configuration, trackingConsent) +} +``` +{{< /site-region >}} + +{{< site-region region="gov" >}} +```kotlin +// in common source set +fun initializeDatadog(context: Any? = null) { + // context should be application context on Android and can be null on iOS + val appClientToken = + val appEnvironment = + val appVariantName = + + val configuration = Configuration.Builder( + clientToken = appClientToken, + env = appEnvironment, + variant = appVariantName + ) + .useSite(DatadogSite.US1_FED) + .trackCrashes(true) + .build() + + Datadog.initialize(context, configuration, trackingConsent) +} +``` +{{< /site-region >}} + +{{< site-region region="ap1" >}} +```kotlin +// in common source set +fun initializeDatadog(context: Any? = null) { + // context should be application context on Android and can be null on iOS + val appClientToken = + val appEnvironment = + val appVariantName = + + val configuration = Configuration.Builder( + clientToken = appClientToken, + env = appEnvironment, + variant = appVariantName + ) + .useSite(DatadogSite.AP1) + .trackCrashes(true) + .build() + + Datadog.initialize(context, configuration, trackingConsent) +} +``` +{{< /site-region >}} +{{< site-region region="ap2" >}} +```kotlin +// in common source set +fun initializeDatadog(context: Any? = null) { + // context should be application context on Android and can be null on iOS + val appClientToken = + val appEnvironment = + val appVariantName = + + val configuration = Configuration.Builder( + clientToken = appClientToken, + env = appEnvironment, + variant = appVariantName + ) + .useSite(DatadogSite.AP2) + .trackCrashes(true) + .build() + + Datadog.initialize(context, configuration, trackingConsent) +} +``` +{{< /site-region >}} + + +## Get deobfuscated stack traces + +Mapping files are used to deobfuscate stack traces, which helps in debugging errors. Using a unique build ID that gets generated, Datadog automatically matches the correct stack traces with the corresponding mapping files. This ensures that regardless of when the mapping file was uploaded (either during pre-production or production builds), the correct information is available for efficient QA processes when reviewing crashes and errors reported in Datadog. + +Use the following guides to see how you can upload mapping files (Android) or dSYMs (iOS) to Datadog: [Android][7], [iOS][8]. +## Limitations +### File sizing +Mapping files are limited in size to **500 MB** each, while dSYM files can go up to **2 GB** each. +### Collection + +The SDK handles crash reporting with the following behaviors: + +- The crash can only be detected after the SDK is initialized. Because of this, Datadog recommends that you initialize the SDK as soon as possible in your application. +- RUM crashes must be attached to a RUM view. If a crash occurs before a view is visible, or after the app is sent to the background by the end-user navigating away from it, the crash is muted and isn't reported for collection. To mitigate this, use the `trackBackgroundEvents()` [method][9] in your `RumConfiguration` builder. +- Only crashes that occur in sampled sessions are kept. + +## Test your implementation + +To verify your Kotlin Multiplatform Crash Reporting and Error Tracking configuration, you need to trigger a crash in your application and confirm that the error appears in Datadog. + +To test your implementation: + +1. Run your application on an Kotlin Multiplatform emulator or a real device. +2. Execute some code containing an error or crash. For example: + + ```kotlin + fun onEvent() { + throw RuntimeException("Crash the app") + } + ``` + +3. After the crash happens, restart your application and wait for the Kotlin Multiplatform SDK to upload the crash report in [**Error Tracking**][1]. + + +## Advanced Error Tracking Features +{{% collapse-content title="Sending data when device is offline" level="h4" %}} + +RUM ensures availability of data when your user device is offline. In case of low-network areas, or when the device battery is too low, all the RUM events are first stored on the local device in batches. + +Each batch follows the intake specification. They are sent as soon as the network is available, and the battery is high enough to ensure the Datadog SDK does not impact the end user's experience. If the network is not available while your application is in the foreground, or if an upload of data fails, the batch is kept until it can be sent successfully. + +This means that even if users open your application while offline, no data is lost. To ensure the SDK does not use too much disk space, the data on the disk is automatically discarded if it gets too old. +{{% /collapse-content %}} + + +{{% collapse-content title="Set tracking consent (GDPR compliance)" level="h4" %}} + +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()`. 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. + +{{% /collapse-content %}} ## Further Reading @@ -185,13 +410,15 @@ For more information about setting up a client token, see the [Client Token docu [602]: /real_user_monitoring/kotlin_multiplatform/data_collected/ [603]: /account_management/api-app-keys/#api-keys [604]: /account_management/api-app-keys/#client-tokens - - @@ -200,8 +427,7 @@ For more information about setting up a client token, see the [Client Token docu [2]: /error_tracking/ -[6]: /getting_started/tagging/using_tags/ -[7]: /real_user_monitoring/application_monitoring/advanced_configuration/kotlin_multiplatform/#initialization-parameters + [8]: https://app.datadoghq.com/rum/application/create [9]: /real_user_monitoring/application_monitoring/advanced_configuration/kotlin_multiplatform/#automatically-track-views [10]: https://github.com/DataDog/dd-sdk-kotlin-multiplatform/tree/develop/integrations/ktor From eb7014c9067780f9f1dcd681de385ecd6e986330 Mon Sep 17 00:00:00 2001 From: Ida Adjivon Date: Thu, 9 Oct 2025 17:05:08 -0400 Subject: [PATCH 3/5] removed et content from the rum>et section --- .../mobile/kotlin-multiplatform.md | 96 +------------------ 1 file changed, 2 insertions(+), 94 deletions(-) diff --git a/content/en/real_user_monitoring/error_tracking/mobile/kotlin-multiplatform.md b/content/en/real_user_monitoring/error_tracking/mobile/kotlin-multiplatform.md index 913a5c7fa5300..3490e81e83d66 100644 --- a/content/en/real_user_monitoring/error_tracking/mobile/kotlin-multiplatform.md +++ b/content/en/real_user_monitoring/error_tracking/mobile/kotlin-multiplatform.md @@ -32,96 +32,10 @@ Your crash reports appear in [**Error Tracking**][1]. ## Setup -If you have not set up the Kotlin Multiplatform SDK yet, follow the [in-app setup instructions][2] or see the [Kotlin Multiplatform setup documentation][3]. +If you have not set up the Kotlin Multiplatform SDK yet, follow the [in-app setup instructions][2] or see the [Kotlin Multiplatform setup documentation][3]. Then, follow the steps in the [Error Tracking documentation to enable Kotlin Crash Reporting and Error Tracking][4]. For any given error, you can access the file path, line number, and a code snippet for each frame of the related stack trace. -### Android - -All uncaught exceptions and ANRs resulting in a crash are reported by the Kotlin Multiplatform SDK (see [limitations](#limitations)). On top of these crashes, you can configure the SDK to report NDK crashes, and control the reporting of non-fatal ANRs. - -#### Add NDK crash reporting - -Your Android application may be running native code (C/C++) for performance or code reusability. To enable NDK crash reporting, use the Datadog NDK library. - -1. Add the Gradle dependency to your Android source set by declaring the library as a dependency in your `build.gradle.kts` file: - -```kotlin -kotlin { - sourceSets { - androidMain.dependencies { - implementation("com.datadoghq:dd-sdk-android-ndk:x.x.x") - } - } -} -``` - -2. Enable NDK crash collection after initializing the SDK. - -``` kotlin -// in Android source set -NdkCrashReports.enable() -``` - -#### Add ANR reporting - -An "Application Not Responding" ([ANR][4]) is an Android-specific type of error that gets triggered when the application is unresponsive for too long. - -For any Android version, you can override the default setting for reporting non-fatal ANRs by setting `trackNonFatalAnrs` (available from Android source set only) to `true` or `false` when initializing the SDK. - -ANRs are only reported through RUM (not through logs). For more information, see [Android Crash Reporting and Error Tracking - Add ANR Reporting][5]. - -### iOS - -**Note**: Kotlin 2.0.20 or higher is required if crash tracking is enabled on iOS. Otherwise, due to the compatibility with `PLCrashReporter`, the application may hang if crash tracking is enabled. See other dependencies in the [setup][10] instructions. - -All uncaught exceptions resulting in a crash are reported by the Kotlin Multiplatform SDK. - -#### Add app hang reporting - -App hangs are an iOS-specific type of error that happens when the application is unresponsive for too long. - -By default, app hangs reporting is **disabled**, but you can enable it and set your own threshold to monitor app hangs that last more than a specified duration by using the `setAppHangThreshold` (available from iOS source set only) initialization method. - -App hangs are only reported through RUM (not through logs). For more information, see [iOS Crash Reporting and Error Tracking - Add ANR Reporting][6]. - -## Get deobfuscated stack traces - -Mapping files are used to deobfuscate stack traces, which helps in debugging errors. Using a unique build ID that gets generated, Datadog automatically matches the correct stack traces with the corresponding mapping files. This ensures that regardless of when the mapping file was uploaded (either during pre-production or production builds), the correct information is available for efficient QA processes when reviewing crashes and errors reported in Datadog. - -Use the following guides to see how you can upload mapping files (Android) or dSYMs (iOS) to Datadog: [Android][7], [iOS][8]. - -## Limitations - -### File sizing - -Mapping files are limited in size to **500 MB** each, while dSYM files can go up to **2 GB** each. - -### Collection - -The SDK handles crash reporting with the following behaviors: - -- The crash can only be detected after the SDK is initialized. Because of this, Datadog recommends that you initialize the SDK as soon as possible in your application. -- RUM crashes must be attached to a RUM view. If a crash occurs before a view is visible, or after the app is sent to the background by the end-user navigating away from it, the crash is muted and isn't reported for collection. To mitigate this, use the `trackBackgroundEvents()` [method][9] in your `RumConfiguration` builder. -- Only crashes that occur in sampled sessions are kept. - -## Test your implementation - -To verify your Kotlin Multiplatform Crash Reporting and Error Tracking configuration, you need to trigger a crash in your application and confirm that the error appears in Datadog. - -To test your implementation: - -1. Run your application on an Kotlin Multiplatform emulator or a real device. -2. Execute some code containing an error or crash. For example: - - ```kotlin - fun onEvent() { - throw RuntimeException("Crash the app") - } - ``` - -3. After the crash happens, restart your application and wait for the Kotlin Multiplatform SDK to upload the crash report in [**Error Tracking**][1]. - ## Further Reading {{< partial name="whats-next/whats-next.html" >}} @@ -129,10 +43,4 @@ To test your implementation: [1]: https://app.datadoghq.com/rum/error-tracking [2]: https://app.datadoghq.com/rum/application/create [3]: /real_user_monitoring/application_monitoring/kotlin_multiplatform/setup -[4]: https://developer.android.com/topic/performance/vitals/anr -[5]: /real_user_monitoring/error_tracking/mobile/android/#add-anr-reporting -[6]: /real_user_monitoring/error_tracking/mobile/ios/#add-app-hang-reporting -[7]: /real_user_monitoring/error_tracking/mobile/android/#get-deobfuscated-stack-traces -[8]: /real_user_monitoring/error_tracking/mobile/ios/#get-deobfuscated-stack-traces -[9]: /real_user_monitoring/application_monitoring/kotlin_multiplatform/setup/#track-background-events -[10]: /real_user_monitoring/application_monitoring/kotlin_multiplatform/setup/#add-native-dependencies-for-ios +[4]: /error_tracking/frontend/mobile/kotlin-multiplatform From 0761c65454c1525ad2b07554b84f06b672240e70 Mon Sep 17 00:00:00 2001 From: Ida Adjivon Date: Thu, 9 Oct 2025 17:09:26 -0400 Subject: [PATCH 4/5] modified the overview page of the rum kotlin setup page --- .../application_monitoring/kotlin_multiplatform/setup.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/content/en/real_user_monitoring/application_monitoring/kotlin_multiplatform/setup.md b/content/en/real_user_monitoring/application_monitoring/kotlin_multiplatform/setup.md index 90cdcc567b15d..b745dcb35229b 100644 --- a/content/en/real_user_monitoring/application_monitoring/kotlin_multiplatform/setup.md +++ b/content/en/real_user_monitoring/application_monitoring/kotlin_multiplatform/setup.md @@ -20,7 +20,7 @@ further_reading: --- ## Overview -This page describes how to instrument your applications for both [Real User Monitoring (RUM)][1] and [Error Tracking][2] with the Kotlin Multiplatform SDK. You can follow the steps below to instrument your applications for RUM (includes Error Tracking) or Error Tracking if you have purchased it as a standalone product. +This page describes how to instrument your applications for [Real User Monitoring (RUM)][1] with the Kotlin Multiplatform SDK. RUM includes Error Tracking by default, but if you have purchased Error Tracking as a standalone product, see the [Error Tracking setup guide][15] for specific steps. The Datadog Kotlin Multiplatform SDK supports Android 5.0+ (API level 21) and iOS v12+. @@ -424,3 +424,4 @@ This means that even if users open your application while offline, no data is lo [12]: /real_user_monitoring/error_tracking/kotlin_multiplatform/ [13]: /real_user_monitoring/explorer/ [14]: https://github.com/DataDog/dd-sdk-kotlin-multiplatform/blob/develop/NATIVE_SDK_VERSIONS.md +[15]: /error_tracking/frontend/mobile/kotlin-multiplatform.md From 6b1c159b17bffb54db0cf6284387156d34f59b65 Mon Sep 17 00:00:00 2001 From: Ida Adjivon Date: Thu, 9 Oct 2025 17:11:29 -0400 Subject: [PATCH 5/5] removed ET section from the rum kotlin setup page --- .../kotlin_multiplatform/setup.md | 21 ++----------------- 1 file changed, 2 insertions(+), 19 deletions(-) diff --git a/content/en/real_user_monitoring/application_monitoring/kotlin_multiplatform/setup.md b/content/en/real_user_monitoring/application_monitoring/kotlin_multiplatform/setup.md index b745dcb35229b..dc38f4e7cefe3 100644 --- a/content/en/real_user_monitoring/application_monitoring/kotlin_multiplatform/setup.md +++ b/content/en/real_user_monitoring/application_monitoring/kotlin_multiplatform/setup.md @@ -98,29 +98,10 @@ If you are integrating Kotlin Multiplatform library as a framework with an `embe ### Specify application details in the UI -{{< tabs >}} -{{% tab "RUM" %}} - 1. Navigate to [**Digital Experience** > **Add an Application**][1]. 2. Select `Kotlin Multiplatform` as the application type and enter an application name to generate a unique Datadog application ID and client token. 3. To disable automatic user data collection for either client IP or geolocation data, uncheck the boxes for those settings. For more information, see [RUM Kotlin Multiplatform Data Collected][2]. -[1]: https://app.datadoghq.com/rum/application/create -[2]: /real_user_monitoring/kotlin_multiplatform/data_collected/ - -{{% /tab %}} -{{% tab "Error Tracking" %}} - -1. Navigate to [**Digital Experience** > **Add an Application**][1]. -2. Select `Kotlin Multiplatform` as the application type and enter an application name to generate a unique Datadog application ID and client token. -3. To disable automatic user data collection for either client IP or geolocation data, uncheck the boxes for those settings. For more information, see [RUM Kotlin Multiplatform Data Collected][2]. - -[1]: https://app.datadoghq.com/error-tracking/settings/setup/client -[2]: /real_user_monitoring/kotlin_multiplatform/data_collected/ - -{{% /tab %}} -{{< /tabs >}} - To ensure the safety of your data, you must use a client token. If you use only [Datadog API keys][4] to configure the Datadog SDK, they are exposed client-side in the Android application's APK byte code. For more information about setting up a client token, see the [Client Token documentation][5]. @@ -425,3 +406,5 @@ This means that even if users open your application while offline, no data is lo [13]: /real_user_monitoring/explorer/ [14]: https://github.com/DataDog/dd-sdk-kotlin-multiplatform/blob/develop/NATIVE_SDK_VERSIONS.md [15]: /error_tracking/frontend/mobile/kotlin-multiplatform.md +[101]: https://app.datadoghq.com/rum/application/create +[102]: /real_user_monitoring/kotlin_multiplatform/data_collected/