Update

Author: buenaflor

docs/platforms/kotlin/guides/compose-multiplatform/index.mdx

@@ -0,0 +1,49 @@
+---
+title: "Compose Multiplatform"
+description: "Learn how to integrate Sentry's Kotlin Multiplatform SDK into your Compose Multiplatform project for cross-platform error tracking."
+sdk: sentry.kotlin.multiplatform
+categories:
+  - kotlin
+  - multiplatform
+sidebar_order: 15
+---
+
+# Compose Multiplatform
+
+<Alert level="warning" title="Experimental Support">
+While Sentry's Kotlin Multiplatform SDK works in Compose Multiplatform projects, it isn't natively supported or fully tested for CMP. Some features may behave unexpectedly or provide incomplete data. Use with caution in production environments and report any issues you encounter.
+</Alert>
+
+## Overview
+
+**Compose Multiplatform** is JetBrains' declarative UI framework that allows you to build native user interfaces for desktop, web, and mobile platforms using a single Kotlin codebase. It extends Jetpack Compose beyond Android to create truly multiplatform applications.
+
+It is required to use the [Sentry Kotlin Multiplatform SDK](/platforms/kotlin/guides/kotlin-multiplatform/) which provides error tracking across multiple Kotlin targets. While the SDK functions in Compose Multiplatform projects using the same APIs as pure KMP setups, it's important to note:
+
+- ✅ **Experimental support**: The KMP SDK works in CMP projects and currently supports capturing crashes and errors as well as other basic features that are available through the Sentry KMP SDK.
+- ⚠️ **Not CMP-native**: No specific CMP optimizations or testing.
+- 🔍 **Untested edge cases**: Some platform-specific behaviors may be incomplete.
+
+## Installation
+
+Sentry captures data by using an SDK within your application's runtime.
+
+<PlatformContent includePath="getting-started-install" />
+
+## Configure
+
+Configuration should happen as early as possible in your application's lifecycle.
+
+<PlatformContent includePath="getting-started-config" />
+
+## Verify
+
+This snippet includes an intentional error, so you can test that everything is working as soon as you set it up.
+
+<PlatformContent includePath="getting-started-verify" />
+
+## Debug Symbols
+
+Error stack traces in your app might appear unreadable or obfuscated, making it hard to debug issues. To make stack traces clear and human-readable in Sentry, you need to upload your app's debug symbols.
+
+For step-by-step instructions, see the [Debug Symbols guide](/platforms/kotlin/guides/kotlin-multiplatform/debug-symbols/).

docs/platforms/kotlin/guides/kotlin-multiplatform/debug-symbols/index.mdx

@@ -15,22 +15,43 @@ For Apple applications please follow the iOS documentation on [Uploading Debug S
 
 ### Gradle
 
-To upload ProGuard mapping files or Native debug symbols via Gradle you need to install the [Sentry Android Gradle](/platforms/android/configuration/gradle) plugin:
+To upload ProGuard mapping files or Native debug symbols via Gradle you need to install the [Sentry Android Gradle Plugin](/platforms/android/configuration/gradle) in your `androidApp` module:
 
 ```kotlin {filename:androidApp/build.gradle.kts}
 plugins {
     id("com.android.application")
     id("io.sentry.android.gradle") version "{{@inject packages.version('sentry.java.android.gradle-plugin', '3.0.0') }}"
 }
 
-// Prevent Sentry dependencies from being included in the Android app through the AGP.
 sentry {
+  // Prevent Sentry dependencies from being included in the Android app through the AGP.
   autoInstallation {
     enabled.set(false)
   }
+  
+  // The slug of the Sentry organization to use for uploading proguard mappings/source contexts.
+  org.set("___ORG_SLUG___")
+
+  // The slug of the Sentry project to use for uploading proguard mappings/source contexts.
+  projectName.set("___PROJECT_SLUG___")
+
+  // The authentication token to use for uploading proguard mappings/source contexts.
+  // WARNING: Do not expose this token in your build.gradle files, but rather set an environment
+  // variable and read it into this property.
+  authToken.set(System.getenv("SENTRY_AUTH_TOKEN"))
 }
 ```
 
+After installing the plugin, you need to configure your auth token as an environment variable:
+
+<OrgAuthTokenNote />
+
+```bash
+export SENTRY_AUTH_TOKEN=___ORG_AUTH_TOKEN___
+```
+
+Once configured, the plugin will automatically upload the necessary debug symbols to Sentry when a release build is created.
+
 #### ProGuard/R8 & DexGuard
 
 Learn more in the Sentry Gradle Plugin docs for [ProGuard/R8 & DexGuard](/platforms/android/configuration/gradle/#proguardr8--dexguard).

platform-includes/getting-started-config/kotlin.compose-multiplatform.mdx

@@ -0,0 +1,19 @@
+Initialize Sentry in your main application entry point, typically in your `main()` function or `App` composable:
+
+```kotlin {filename:App.kt}
+import io.sentry.kotlin.multiplatform.Sentry
+import androidx.compose.runtime.Composable
+
+@Composable
+fun App() {
+    // Initialize Sentry when your app starts
+    Sentry.init { options ->
+        options.dsn = "___PUBLIC_DSN___"
+        // Adds request headers and IP for users, for more info visit:
+        // https://docs.sentry.io/platforms/kotlin/guides/kotlin-multiplatform/data-management/data-collected/
+        options.sendDefaultPii = true
+    }
+    
+    // ... your compose UI content
+}
+```

platform-includes/getting-started-install/kotlin.compose-multiplatform.mdx

@@ -0,0 +1,19 @@
+To install the Kotlin Multiplatform SDK in your Compose Multiplatform project, you need to add the following to your `build.gradle.kts` file in your shared module:
+
+```kotlin {filename:composeApp/build.gradle.kts}
+plugins {
+  id("io.sentry.kotlin.multiplatform.gradle") version "{{@inject packages.version('sentry.kotlin.kmp.gradle-plugin', '0.9.0') }}"
+}
+```
+
+The plugin does the following:
+
+- Automatically installs the Sentry KMP dependency to `commonMain`. 
+- If you use the Kotlin Cocoapods plugin, it installs the Sentry Cocoa dependency.
+- If you use Swift Package Manager, it sets up linking to the Sentry Cocoa framework.
+
+<Alert>
+
+If you use Swift Package Manager instead of Cocoapods, you need to install the [sentry-cocoa dependency with Swift Package Manager](/platforms/apple/install/swift-package-manager/) in your Xcode project first before executing the Gradle plugin. 
+
+</Alert>

platform-includes/getting-started-install/kotlin.kotlin-multiplatform.mdx

@@ -2,11 +2,16 @@ To install the Kotlin Multiplatform SDK, you need to add the following to your `
 
 ```kotlin {filename:shared/build.gradle.kts}
 plugins {
-  id("io.sentry.kotlin.multiplatform.gradle") version "{{@inject packages.version('sentry.kotlin.kmp', '0.9.0') }}"
+  id("io.sentry.kotlin.multiplatform.gradle") version "{{@inject packages.version('sentry.kotlin.kmp.gradle-plugin', '0.9.0') }}"
 }
 ```
 
-The plugin installs the Sentry KMP dependency. If you're using the Cocoapods plugin, it will also install the Sentry Cocoa dependency.
+The plugin does the following:
+
+- Automatically installs the Sentry KMP dependency to `commonMain`. 
+- If you use the Kotlin Cocoapods plugin, it installs the Sentry Cocoa dependency.
+- If you use Swift Package Manager, it sets up linking to the Sentry Cocoa framework.
+
 
 <Alert>
 

platform-includes/getting-started-verify/kotlin.compose-multiplatform.mdx

@@ -0,0 +1,14 @@
+```kotlin
+import io.sentry.kotlin.multiplatform.Sentry
+
+// Add the following button to your compose UI and click it to trigger an error
+Button(onClick = {
+    try {
+        throw Exception("Sentry works!")
+    } catch (e: Exception) {
+        Sentry.captureException(e)
+    }
+}) {
+    Text("Send an error to Sentry")
+}
+```