[DOCS-14020] Split SDK advanced_config partials into use-case buckets

layouts/shortcodes/mdoc/en/sdk/add_custom_context/android.mdoc.md

@@ -0,0 +1,13 @@
+### Track attributes
+
+```kotlin
+// Adds an attribute to all future RUM events
+GlobalRumMonitor.get().addAttribute(key, value)
+
+// Removes an attribute to all future RUM events
+GlobalRumMonitor.get().removeAttribute(key)
+```
+
+[1]: https://app.datadoghq.com/rum/application/create
+[2]: /real_user_monitoring/android
+[3]: /real_user_monitoring/android/data_collected

layouts/shortcodes/mdoc/en/sdk/add_custom_context/flutter.mdoc.md

@@ -0,0 +1,9 @@
+### Set a custom global attribute
+
+To set a custom global attribute, use `DdRum.addAttribute`.
+
+* To add or update an attribute, use `DdRum.addAttribute`.
+* To remove the key, use `DdRum.removeAttribute`.
+
+[1]: https://app.datadoghq.com/rum/application/create
+[14]: /real_user_monitoring/application_monitoring/flutter/data_collected

layouts/shortcodes/mdoc/en/sdk/add_custom_context/ios.mdoc.md

@@ -0,0 +1,15 @@
+### Set a custom global attribute
+
+To set a custom global attribute, use `RUMMonitor.shared().addAttribute(forKey:value:)`.
+
+* To add an attribute, use `RUMMonitor.shared().addAttribute(forKey: "<KEY>", value: "<VALUE>")`.
+* To update the value, use `RUMMonitor.shared().addAttribute(forKey: "<KEY>", value: "<UPDATED_VALUE>")`.
+* To remove the key, use `RUMMonitor.shared().removeAttribute(forKey: "<KEY_TO_REMOVE>")`.
+
+For better performance in bulk operations (modifying multiple attributes at once), use `.addAttributes(_:)` and `.removeAttributes(forKeys:)`.
+
+**Note**: You can't create facets on custom attributes if you use spaces or special characters in your key names. For example, use `forKey: "store_id"` instead of `forKey: "Store ID"`.
+
+[1]: https://app.datadoghq.com/rum/application/create
+[2]: /real_user_monitoring/application_monitoring/ios
+[6]: /real_user_monitoring/application_monitoring/ios/data_collected/?tab=session#default-attributes

layouts/shortcodes/mdoc/en/sdk/add_custom_context/kotlin_multiplatform.mdoc.md

@@ -0,0 +1,12 @@
+### Track attributes
+
+```kotlin
+// Adds an attribute to all future RUM events
+GlobalRumMonitor.get().addAttribute(key, value)
+
+// Removes an attribute to all future RUM events
+GlobalRumMonitor.get().removeAttribute(key)
+```
+
+[1]: https://app.datadoghq.com/rum/application/create
+[3]: /real_user_monitoring/application_monitoring/kotlin_multiplatform/data_collected

layouts/shortcodes/mdoc/en/sdk/add_custom_context/react_native.mdoc.md

@@ -0,0 +1,52 @@
+### Global attributes
+
+You can keep global attributes to track information about a specific session, such as A/B testing configuration, ad campaign origin, or cart status. These attributes are attached to all future Logs, Spans, and RUM events.
+
+**Add multiple global attributes**
+
+Use `addAttributes` to add or update several attributes at once.
+
+```js
+DdSdkReactNative.addAttributes({
+    profile_mode: 'wall',
+    chat_enabled: true,
+    campaign_origin: 'example_ad_network'
+});
+```
+
+**Add a single global attribute**
+
+Use `addAttribute` when you want to add or update a single attribute.
+
+```js
+DdSdkReactNative.addAttribute('profile_mode', 'wall');
+DdSdkReactNative.addAttribute('chat_enabled', true);
+```
+
+If the attribute already exists, its value is overwritten.
+
+**Remove a single global attribute**
+
+Use `removeAttribute` to remove a specific attribute from the global context.
+
+```js
+DdSdkReactNative.removeAttribute('campaign_origin');
+```
+
+After removal, the attribute is no longer attached to future Logs, Spans, or RUM events.
+
+**Remove multiple global attributes**
+
+Use `removeAttributes` to remove several attributes at once.
+
+```js
+DdSdkReactNative.removeAttributes([
+    'profile_mode',
+    'chat_enabled'
+]);
+```
+
+This is useful when cleaning up session-specific data, such as when a user logs out or exits a feature flow.
+
+[1]: https://app.datadoghq.com/rum/application/create
+[2]: /real_user_monitoring/application_monitoring/react_native

layouts/shortcodes/mdoc/en/sdk/add_custom_context/roku.mdoc.md

@@ -0,0 +1,10 @@
+### Track custom global attributes
+
+In addition to the default attributes captured by the SDK automatically, you can choose to add additional contextual information, such as custom attributes, to your Logs and RUM events to enrich your observability within Datadog. Custom attributes allow you to filter and group information about observed user behavior (for example by cart value, merchant tier, or ad campaign) with code-level information (such as backend services, session timeline, error logs, and network health).
+
+```text
+    m.global.setField("datadogContext", { foo: "Some value", bar: 123})
+```
+
+[1]: https://app.datadoghq.com/rum/application/create
+[2]: /real_user_monitoring/application_monitoring/roku/setup

layouts/shortcodes/mdoc/en/sdk/add_custom_context/unity.mdoc.md

@@ -0,0 +1,9 @@
+### Set a custom global attribute
+
+To set a custom global attribute, use `DdRum.AddAttribute`.
+
+* To add or update an attribute, use `DdRum.AddAttribute`.
+* To remove the key, use `DdRum.RemoveAttribute`.
+
+[1]: https://app.datadoghq.com/rum/application/create
+[3]: /real_user_monitoring/application_monitoring/unity/data_collected/

layouts/shortcodes/mdoc/en/sdk/manage_sessions/android.mdoc.md

@@ -0,0 +1,79 @@
+## Event and data management
+
+The Android SDK first stores events and only uploads events when the [intake specifications][8] conditions are met.
+
+### Clear all data
+
+You have the option of deleting all unsent data stored by the SDK with the `clearAllData` API.
+
+```kotlin
+fun clearAllData(sdkCore: SdkCore = getInstance()) {
+    sdkCore.clearAllData()
+}
+```
+
+### Stop data collection
+
+You can use the `StopInstance` API to stop the SDK instance assigned to the given name (or the default instance if the name is null) from collecting and uploading data further.
+
+```kotlin
+fun stopInstance(instanceName: String? = null) {
+    synchronized(registry) {
+        val instance = registry.unregister(instanceName)
+        (instance as? DatadogCore)?.stop()
+    }
+}
+```
+
+### Control event buildup
+
+Many operations, such as data processing and event I/O, are queued in background threads to handle edge cases where the queue has grown so much that there could be delayed processing, high memory usage, or Application Not Responding (ANR) errors.
+
+You can control the buildup of events on the SDK with the `setBackpressureStrategy` API. This API ignores new tasks if a queue reaches 1024 items.
+
+```kotlin
+fun setBackpressureStrategy(backpressureStrategy: BackPressureStrategy): Builder {
+    coreConfig = coreConfig.copy(backpressureStrategy = backpressureStrategy)
+    return this
+}
+```
+
+See an [example of this API][9] being used.
+
+### Set remote log threshold
+
+You can define the minimum log level (priority) to send events to Datadog in a logger instance. If the log priority is below the one you set at this threshold, it does not get sent. The default value is -1 (allow all).
+
+```kotlin
+fun setRemoteLogThreshold(minLogThreshold: Int): Builder {
+    minDatadogLogsPriority = minLogThreshold
+    return this
+}
+```
+
+## Retrieve the RUM session ID
+
+Retrieving the RUM session ID can be helpful for troubleshooting. For example, you can attach the session ID to support requests, emails, or bug reports so that your support team can later find the user session in Datadog.
+
+You can access the RUM session ID at runtime without waiting for the `sessionStarted` event:
+
+```kotlin
+GlobalRumMonitor.get().getCurrentSessionId { sessionId ->
+  currentSessionId = sessionId
+}
+```
+
+[1]: https://app.datadoghq.com/rum/application/create
+[2]: /real_user_monitoring/android
+[3]: /real_user_monitoring/android/data_collected
+[4]: /real_user_monitoring/application_monitoring/android/advanced_configuration/#automatically-track-views
+[5]: /real_user_monitoring/application_monitoring/android/advanced_configuration/#initialization-parameters
+[6]: /real_user_monitoring/application_monitoring/android/advanced_configuration/#automatically-track-network-requests
+[7]: /real_user_monitoring/android/data_collected/#event-specific-attributes
+[8]: /real_user_monitoring/application_monitoring/android/setup/#sending-data-when-device-is-offline
+[9]: https://github.com/DataDog/dd-sdk-android/blob/eaa15cd344d1723fafaf179fcebf800d6030c6bb/sample/kotlin/src/main/kotlin/com/datadog/android/sample/SampleApplication.kt#L279
+[10]: https://github.com/DataDog/dd-sdk-android/tree/master/sample/kotlin/src/main/kotlin/com/datadog/android/sample/widget
+[11]: /real_user_monitoring/application_monitoring/android/monitoring_app_performance/#time-to-network-settled
+[12]: https://square.github.io/okhttp/features/events/
+[13]: /real_user_monitoring/application_monitoring/android/monitoring_app_performance/#interaction-to-next-view
+[14]: /real_user_monitoring/application_monitoring/android/setup?tab=kotlin#setup

layouts/shortcodes/mdoc/en/sdk/manage_sessions/flutter.mdoc.md

@@ -0,0 +1,66 @@
+## Tracking from background isolates
+
+Starting with v3, Datadog Flutter SDK is capable of monitoring from multiple isolates, but monitoring must be initialized from the background isolate:
+
+When initializing your background isolate, call `DatadogSdk.instance.attachToBackgroundIsolate`. For example:
+
+```dart
+Future<void> _spawnIsolate() async {
+    final receivePort = ReceivePort();
+    receivePort.listen((message) {
+      //
+    });
+    await Isolate.spawn(_backgroundWork, receivePort.sendPort);
+  }
+
+void _backgroundWork(SendPort port) async {
+  await DatadogSdk.instance.attachToBackgroundIsolate();
+
+  // Your background work
+}
+```
+
+`attachToBackgroundIsolate` must be called **after** Datadog is initialized in your main isolate, otherwise the call silently fails and tracking is not available.
+
+If you are using [Datadog Tracking HTTP Client][10] to automatically track resources, `attachToBackgroundIsolate` automatically starts tracking resources from the calling isolate. However, using `Client` from the `http` package or `Dio` requires you to re-initialize HTTP tracking for those packages from the background isolate.
+
+## Clear all data
+
+Use `clearAllData` to clear all data that has not been sent to Datadog.
+
+```dart
+DatadogSdk.instance.clearAllData();
+```
+
+## Retrieve the RUM session ID
+
+Retrieving the RUM session ID can be helpful for troubleshooting. For example, you can attach the session ID to support requests, emails, or bug reports so that your support team can later find the user session in Datadog.
+
+You can access the RUM session ID at runtime without waiting for the `sessionStarted` event:
+
+```dart
+final sessionId = await DatadogSdk.instance.rum?.getCurrentSessionId()
+```
+
+[1]: https://app.datadoghq.com/rum/application/create
+[2]: /real_user_monitoring/application_monitoring/flutter/setup/
+[3]: /real_user_monitoring/application_monitoring/flutter/integrated_libraries/
+[4]: /getting_started/tagging/#defining-tags
+[5]: /real_user_monitoring/connect_rum_and_traces/?tab=browserrum#how-are-rum-resources-linked-to-traces
+[6]: https://github.com/openzipkin/b3-propagation#single-headers
+[7]: https://github.com/openzipkin/b3-propagation#multiple-headers
+[8]: https://www.w3.org/TR/trace-context/#tracestate-header
+[9]: /real_user_monitoring/application_monitoring/browser/frustration_signals/
+[10]: https://pub.dev/packages/datadog_tracking_http_client
+[11]: https://api.flutter.dev/flutter/dart-io/HttpOverrides/current.html
+[12]: https://pub.dev/documentation/datadog_tracking_http_client/latest/datadog_tracking_http_client/DatadogTrackingHttpOverrides-class.html
+[13]: /serverless/aws_lambda/distributed_tracing/
+[14]: /real_user_monitoring/application_monitoring/flutter/data_collected
+[15]: /real_user_monitoring/explorer/?tab=measures#setup-facets-and-measures
+[16]: https://github.com/DataDog/dd-sdk-flutter/tree/main/packages/datadog_tracking_http_client
+[17]: https://pub.dev/documentation/datadog_flutter_plugin/latest/datadog_flutter_plugin/
+[18]: /real_user_monitoring/application_monitoring/mobile_vitals/?tab=flutter
+[19]: https://pub.dev/packages/datadog_grpc_interceptor
+[20]: https://pub.dev/packages/datadog_gql_link
+[21]: https://pub.dev/packages/datadog_dio
+[22]: /real_user_monitoring/application_monitoring/flutter/integrated_libraries

layouts/shortcodes/mdoc/en/sdk/manage_sessions/ios.mdoc.md

@@ -0,0 +1,85 @@
+## Track background events
+
+{% alert level="info" %}
+Tracking background events may lead to additional sessions, which can impact billing. For questions, [contact Datadog support](https://docs.datadoghq.com/help/).
+{% /alert %}
+
+You can track events such as crashes and network requests when your application is in the background (for example, no active view is available).
+
+To track background events, add the following snippet during initialization in your Datadog configuration:
+
+```swift
+import DatadogRUM
+
+RUM.enable(
+  with: RUM.Configuration(
+    ...
+    trackBackgroundEvents: true
+  )
+)
+```
+
+## Retrieve the RUM session ID
+
+Retrieving the RUM session ID can be helpful for troubleshooting. For example, you can attach the session ID to support requests, emails, or bug reports so that your support team can later find the user session in Datadog.
+
+You can access the RUM session ID at runtime without waiting for the `sessionStarted` event:
+
+```swift
+RumMonitor.shared().currentSessionID(completion: { sessionId in
+  currentSessionId = sessionId
+})
+```
+
+## Set tracking consent (GDPR compliance)
+
+To be compliant with the GDPR regulation, the RUM iOS SDK requires the tracking consent value at initialization.
+
+The `trackingConsent` setting can be one of the following values:
+
+1. `.pending`: The RUM iOS SDK starts collecting and batching the data but does not send it to Datadog. The RUM iOS SDK waits for the new tracking consent value to decide what to do with the batched data.
+2. `.granted`: The RUM iOS SDK starts collecting the data and sends it to Datadog.
+3. `.notGranted`: The RUM iOS SDK does not collect any data. No logs, traces, or RUM events are sent to Datadog.
+
+To change the tracking consent value after the RUM iOS SDK is initialized, use the `Datadog.set(trackingConsent:)` API call. The RUM iOS SDK changes its behavior according to the new value.
+
+For example, if the current tracking consent is `.pending`:
+
+- If you change the value to `.granted`, the RUM iOS SDK sends all current and future data to Datadog;
+- If you change the value to `.notGranted`, the RUM iOS SDK wipes all current data and does not collect future data.
+
+## Data management
+
+The iOS SDK first stores events locally and only uploads events when the [intake specifications][9] conditions are met.
+
+### Clear all data
+
+You have the option of deleting all unsent data stored by the SDK with the `Datadog.clearAllData()` API.
+
+```swift
+import DatadogCore
+
+Datadog.clearAllData()
+```
+
+### Stop data collection
+
+You can use the `Datadog.stopInstance()` API to stop a named SDK instance (or the default instance if the name is `nil`) from collecting and uploading data further.
+
+```swift
+import DatadogCore
+
+Datadog.stopInstance()
+```
+
+Calling this method disables the SDK and all active features, such as RUM. To resume data collection, you must reinitialize the SDK. You can use this API if you want to change configurations dynamically.
+
+[1]: https://app.datadoghq.com/rum/application/create
+[2]: /real_user_monitoring/application_monitoring/ios
+[3]: /real_user_monitoring/application_monitoring/ios/data_collected/
+[4]: https://github.com/DataDog/dd-sdk-ios/blob/master/DatadogRUM/Sources/RUMMonitorProtocol.swift
+[5]: /real_user_monitoring/application_monitoring/ios/data_collected/?tab=error#error-attributes
+[6]: /real_user_monitoring/application_monitoring/ios/data_collected/?tab=session#default-attributes
+[7]: https://www.ntppool.org/en/
+[8]: /real_user_monitoring/error_tracking/mobile/ios/#add-app-hang-reporting
+[9]: /real_user_monitoring/application_monitoring/ios/setup