feat(kmp): add Compose Multiplatform guide & clean up (#14392)

Adds a guide for `Compose Multiplatform` and cleans up some docs around
KMP

---------

Co-authored-by: Cursor Agent <[email protected]>
Co-authored-by: Alex Krawiec <[email protected]>

Author: 3 people

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 (CMP) 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 multiplatform applications.
+
+You need 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 use the same APIs as pure KMP setups, it's important to note a few differences:
+
+- **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 to ensure a working instrumentation. Configure with the following steps:
+
+<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,52 @@
+1. Add a function to initialize Sentry to your shared module (`commonMain`).
+2. Call the function in your iOS and Android app modules.
+
+```kotlin {filename:SentrySetup.kt}{tabTitle: commonMain}
+import io.sentry.kotlin.multiplatform.Sentry
+
+fun initializeSentry() {
+  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
+  }
+}
+```
+```swift {tabTitle: iosApp}
+import ComposeApp // Replace this with the name of the shared framework
+
+@main
+struct iOSApp: App {
+    init() {
+        SentrySetupKt.initializeSentry()
+    }
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+        }
+    }
+}
+
+// OR alternatively in AppDelegate:
+
+
+func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil
+) -> Bool {
+    SentrySetupKt.initializeSentry()
+    return true
+}
+
+```
+```kotlin {filename:MainActivity.kt}{tabTitle: androidApp}
+import your.kmp.app.initializeSentry
+
+class YourApplication : Application() {
+  override fun onCreate() {
+    super.onCreate()
+      initializeSentry()
+   }
+}
+```

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 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")
+}
+```