feat: beforeSend / fingerprinting (#70)

* add initial jvm impl

* implement hook for apple

* add more SentryEvent fields

* format code

* add SentryId to event

* remove prints

* fix setting context for Apple

* improve consistency

* consistency

* add minor docs

* ref: non-null init for Apple SentryEvent

* add changelog

* document thread-safety and improve null-safety

* remove boilerplate this

* remove boilerplate this

* add more unit tests

* remove this

* make breadcrumbs, tags, fingerprints and exceptions mutable

* use internal set for context

* fix tests

* change to non null collections and improve docs

* remove this scope from extension fun

* fix warnings

Author: buenaflor

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Features
 
+- feat: beforeSend / fingerprinting ([#70](https://github.com/getsentry/sentry-kotlin-multiplatform/pull/70))
 - feat: configuring http client errors for Apple targets ([#76](https://github.com/getsentry/sentry-kotlin-multiplatform/pull/76))
 - feat: improve Objc/Swift experience with @HiddenFromObjc ([#62](https://github.com/getsentry/sentry-kotlin-multiplatform/pull/62))
 - feat: add view hierarchy ([#53](https://github.com/getsentry/sentry-kotlin-multiplatform/pull/53))

gradle.properties

@@ -1,5 +1,4 @@
 # Kotlin
-kotlin.version=1.8.0
 kotlin.incremental.multiplatform=true
 kotlin.code.style=official
 kotlin.mpp.stability.nowarn=true

sentry-kotlin-multiplatform/src/commonAppleMain/kotlin/io/sentry/kotlin/multiplatform/SentryEvent.kt

@@ -0,0 +1,57 @@
+package io.sentry.kotlin.multiplatform
+
+import io.sentry.kotlin.multiplatform.extensions.toKmpBreadcrumb
+import io.sentry.kotlin.multiplatform.extensions.toKmpMessage
+import io.sentry.kotlin.multiplatform.extensions.toKmpSentryException
+import io.sentry.kotlin.multiplatform.extensions.toKmpSentryLevel
+import io.sentry.kotlin.multiplatform.extensions.toKmpUser
+import io.sentry.kotlin.multiplatform.protocol.Message
+import io.sentry.kotlin.multiplatform.protocol.SentryException
+import io.sentry.kotlin.multiplatform.protocol.SentryId
+import io.sentry.kotlin.multiplatform.protocol.User
+
+public actual class SentryEvent actual constructor() : SentryBaseEvent() {
+    public actual var level: SentryLevel? = null
+    public actual var message: Message? = null
+    public actual var logger: String? = null
+    public actual var fingerprint: MutableList<String> = mutableListOf()
+    public actual var exceptions: MutableList<SentryException> = mutableListOf()
+    public override var release: String? = null
+    public override var environment: String? = null
+    public override var platform: String? = null
+    public override var user: User? = null
+    public override var serverName: String? = null
+    public override var dist: String? = null
+
+    public constructor(cocoaSentryEvent: CocoaSentryEvent) : this() {
+        eventId = SentryId(cocoaSentryEvent.eventId.toString())
+        level = cocoaSentryEvent.level?.toKmpSentryLevel()
+        message = cocoaSentryEvent.message?.toKmpMessage()
+        logger = cocoaSentryEvent.logger
+        release = cocoaSentryEvent.releaseName
+        environment = cocoaSentryEvent.environment
+        platform = cocoaSentryEvent.platform
+        user = cocoaSentryEvent.user?.toKmpUser()
+        serverName = cocoaSentryEvent.serverName
+        dist = cocoaSentryEvent.dist
+
+        val cocoaFingerprint =
+            cocoaSentryEvent.fingerprint()?.toMutableList() as? MutableList<String>
+        val cocoaSentryExceptions =
+            cocoaSentryEvent.exceptions?.map { (it as CocoaSentryException).toKmpSentryException() }
+                ?.toMutableList()
+        val cocoaContexts =
+            cocoaSentryEvent.context?.mapKeys { it.key as String }?.mapValues { it.value as Any }
+        val cocoaBreadcrumbs = cocoaSentryEvent.breadcrumbs?.mapNotNull { it as? CocoaBreadcrumb }
+            ?.map { it.toKmpBreadcrumb() }?.toMutableList()
+        val cocoaTags =
+            cocoaSentryEvent.tags?.mapKeys { it.key as String }?.mapValues { it.value as String }
+                ?.toMutableMap()
+
+        cocoaFingerprint?.let { fingerprint = it }
+        cocoaSentryExceptions?.let { exceptions = it }
+        cocoaContexts?.let { contexts = it }
+        cocoaBreadcrumbs?.let { breadcrumbs = it }
+        cocoaTags?.let { tags = it }
+    }
+}

sentry-kotlin-multiplatform/src/commonAppleMain/kotlin/io/sentry/kotlin/multiplatform/TypeAliases.kt

@@ -2,8 +2,11 @@ package io.sentry.kotlin.multiplatform
 
 import cocoapods.Sentry.SentryAttachment
 import cocoapods.Sentry.SentryBreadcrumb
+import cocoapods.Sentry.SentryEvent
+import cocoapods.Sentry.SentryException
 import cocoapods.Sentry.SentryId
 import cocoapods.Sentry.SentryLevel
+import cocoapods.Sentry.SentryMessage
 import cocoapods.Sentry.SentryOptions
 import cocoapods.Sentry.SentryScope
 import cocoapods.Sentry.SentryUser
@@ -17,3 +20,6 @@ internal typealias CocoaSentryId = SentryId
 internal typealias CocoaSentryLevel = SentryLevel
 internal typealias CocoaAttachment = SentryAttachment
 internal typealias CocoaUserFeedback = SentryUserFeedback
+internal typealias CocoaSentryEvent = SentryEvent
+internal typealias CocoaMessage = SentryMessage
+internal typealias CocoaSentryException = SentryException

sentry-kotlin-multiplatform/src/commonAppleMain/kotlin/io/sentry/kotlin/multiplatform/extensions/MessageExtensions.kt

@@ -0,0 +1,19 @@
+package io.sentry.kotlin.multiplatform.extensions
+
+import io.sentry.kotlin.multiplatform.CocoaMessage
+import io.sentry.kotlin.multiplatform.protocol.Message
+
+internal fun CocoaMessage.toKmpMessage() = Message(
+    message = message,
+    params = params as? List<String>,
+    formatted = formatted
+)
+
+internal fun Message.toCocoaMessage(): CocoaMessage {
+    val scope = this@toCocoaMessage
+    val cocoaMessage = scope.formatted?.let { CocoaMessage(it) } ?: CocoaMessage()
+    return cocoaMessage.apply {
+        message = scope.message
+        params = scope.params
+    }
+}

sentry-kotlin-multiplatform/src/commonAppleMain/kotlin/io/sentry/kotlin/multiplatform/extensions/SentryEventExtensions.kt

@@ -0,0 +1,22 @@
+package io.sentry.kotlin.multiplatform.extensions
+
+import cocoapods.Sentry.SentryId
+import io.sentry.kotlin.multiplatform.CocoaSentryEvent
+import io.sentry.kotlin.multiplatform.SentryEvent
+
+internal fun CocoaSentryEvent.applyKmpEvent(kmpEvent: SentryEvent): CocoaSentryEvent {
+    kmpEvent.level?.let { level = it.toCocoaSentryLevel() }
+    kmpEvent.platform?.let { platform = it }
+    message = kmpEvent.message?.toCocoaMessage()
+    logger = kmpEvent.logger
+    fingerprint = kmpEvent.fingerprint
+    releaseName = kmpEvent.release
+    environment = kmpEvent.environment
+    user = kmpEvent.user?.toCocoaUser()
+    serverName = kmpEvent.serverName
+    dist = kmpEvent.dist
+    breadcrumbs = kmpEvent.breadcrumbs?.map { it.toCocoaBreadcrumb() }?.toMutableList()
+    tags = kmpEvent.tags?.toMutableMap()
+    eventId = SentryId(kmpEvent.eventId.toString())
+    return this
+}

sentry-kotlin-multiplatform/src/commonAppleMain/kotlin/io/sentry/kotlin/multiplatform/extensions/SentryExceptionExtensions.kt

@@ -0,0 +1,11 @@
+package io.sentry.kotlin.multiplatform.extensions
+
+import io.sentry.kotlin.multiplatform.CocoaSentryException
+import io.sentry.kotlin.multiplatform.protocol.SentryException
+
+internal fun CocoaSentryException.toKmpSentryException() = SentryException(
+    type = type,
+    value = value,
+    module = module,
+    threadId = threadId as Long?
+)

sentry-kotlin-multiplatform/src/commonAppleMain/kotlin/io/sentry/kotlin/multiplatform/extensions/SentryOptionsExtensions.kt

@@ -1,10 +1,11 @@
 package io.sentry.kotlin.multiplatform.extensions
 
 import PrivateSentrySDKOnly.Sentry.PrivateSentrySDKOnly
-import cocoapods.Sentry.SentryEvent
 import cocoapods.Sentry.SentryHttpStatusCodeRange
 import io.sentry.kotlin.multiplatform.BuildKonfig
+import io.sentry.kotlin.multiplatform.CocoaSentryEvent
 import io.sentry.kotlin.multiplatform.CocoaSentryOptions
+import io.sentry.kotlin.multiplatform.SentryEvent
 import io.sentry.kotlin.multiplatform.SentryOptions
 import io.sentry.kotlin.multiplatform.nsexception.dropKotlinCrashEvent
 import kotlinx.cinterop.convert
@@ -19,19 +20,19 @@ internal fun SentryOptions.toCocoaOptionsConfiguration(): (CocoaSentryOptions?)
  * This avoids code duplication for init on iOS.
  */
 internal fun CocoaSentryOptions.applyCocoaBaseOptions(options: SentryOptions) {
-    this.dsn = options.dsn
-    this.attachStacktrace = options.attachStackTrace
-    this.dist = options.dist
+    dsn = options.dsn
+    attachStacktrace = options.attachStackTrace
+    dist = options.dist
     options.environment?.let {
-        this.environment = it
+        environment = it
     }
-    this.releaseName = options.release
-    this.debug = options.debug
-    this.sessionTrackingIntervalMillis = options.sessionTrackingIntervalMillis.convert()
-    this.enableAutoSessionTracking = options.enableAutoSessionTracking
-    this.maxAttachmentSize = options.maxAttachmentSize.convert()
-    this.maxBreadcrumbs = options.maxBreadcrumbs.convert()
-    this.beforeSend = { event ->
+    releaseName = options.release
+    debug = options.debug
+    sessionTrackingIntervalMillis = options.sessionTrackingIntervalMillis.convert()
+    enableAutoSessionTracking = options.enableAutoSessionTracking
+    maxAttachmentSize = options.maxAttachmentSize.convert()
+    maxBreadcrumbs = options.maxBreadcrumbs.convert()
+    beforeSend = { event ->
         val cocoaName = BuildKonfig.SENTRY_COCOA_PACKAGE_NAME
         val cocoaVersion = BuildKonfig.SENTRY_COCOA_VERSION
 
@@ -49,14 +50,20 @@ internal fun CocoaSentryOptions.applyCocoaBaseOptions(options: SentryOptions) {
         sdk?.set("packages", packages)
 
         event?.sdk = sdk
-        dropKotlinCrashEvent(event as NSExceptionSentryEvent?) as SentryEvent?
+
+        val modifiedEvent = event?.let { SentryEvent(it) }?.let { unwrappedEvent ->
+            val result = options.beforeSend?.invoke(unwrappedEvent)
+            result?.let { event.applyKmpEvent(it) }
+        }
+
+        dropKotlinCrashEvent(modifiedEvent as NSExceptionSentryEvent?) as CocoaSentryEvent?
     }
 
     val sdkName = options.sdk?.name ?: BuildKonfig.SENTRY_KMP_COCOA_SDK_NAME
     val sdkVersion = options.sdk?.version ?: BuildKonfig.VERSION_NAME
     PrivateSentrySDKOnly.setSdkName(sdkName, sdkVersion)
 
-    this.beforeBreadcrumb = { cocoaBreadcrumb ->
+    beforeBreadcrumb = { cocoaBreadcrumb ->
         cocoaBreadcrumb?.toKmpBreadcrumb()
             ?.let { options.beforeBreadcrumb?.invoke(it) }?.toCocoaBreadcrumb()
     }

sentry-kotlin-multiplatform/src/commonAppleMain/kotlin/io/sentry/kotlin/multiplatform/extensions/UserExtensions.kt

@@ -13,9 +13,8 @@ internal fun User.toCocoaUser() = CocoaUser().apply {
 
 internal fun CocoaUser.toKmpUser() = User().apply {
     val scope = this@toKmpUser
-    id = scope.userId.toString()
-    username = scope.username.toString()
-    email = scope.email.toString()
-    ipAddress = scope.ipAddress.toString()
-    setData(scope.data)
+    id = scope.userId
+    username = scope.username
+    email = scope.email
+    ipAddress = scope.ipAddress
 }

sentry-kotlin-multiplatform/src/commonJvmMain/kotlin/io/sentry/kotlin/multiplatform/SentryEvent.kt

@@ -0,0 +1,43 @@
+package io.sentry.kotlin.multiplatform
+
+import io.sentry.kotlin.multiplatform.extensions.toKmpBreadcrumb
+import io.sentry.kotlin.multiplatform.extensions.toKmpMessage
+import io.sentry.kotlin.multiplatform.extensions.toKmpSentryException
+import io.sentry.kotlin.multiplatform.extensions.toKmpSentryLevel
+import io.sentry.kotlin.multiplatform.extensions.toKmpUser
+import io.sentry.kotlin.multiplatform.protocol.Message
+import io.sentry.kotlin.multiplatform.protocol.SentryException
+import io.sentry.kotlin.multiplatform.protocol.SentryId
+import io.sentry.kotlin.multiplatform.protocol.User
+
+public actual class SentryEvent actual constructor() : SentryBaseEvent() {
+    public actual var level: SentryLevel? = null
+    public actual var message: Message? = null
+    public actual var logger: String? = null
+    public actual var fingerprint: MutableList<String> = mutableListOf()
+    public actual var exceptions: MutableList<SentryException> = mutableListOf()
+    public override var release: String? = null
+    public override var environment: String? = null
+    public override var platform: String? = null
+    public override var user: User? = null
+    public override var serverName: String? = null
+    public override var dist: String? = null
+
+    public constructor(jvmSentryEvent: JvmSentryEvent) : this() {
+        eventId = SentryId(jvmSentryEvent.eventId.toString())
+        level = jvmSentryEvent.level?.toKmpSentryLevel()
+        message = jvmSentryEvent.message?.toKmpMessage()
+        logger = jvmSentryEvent.logger
+        release = jvmSentryEvent.release
+        environment = jvmSentryEvent.environment
+        platform = jvmSentryEvent.platform
+        user = jvmSentryEvent.user?.toKmpUser()
+        serverName = jvmSentryEvent.serverName
+        dist = jvmSentryEvent.dist
+        contexts = jvmSentryEvent.contexts
+        jvmSentryEvent.fingerprints?.let { fingerprint = it }
+        jvmSentryEvent.exceptions?.let { exceptions = it.map { it.toKmpSentryException() }.toMutableList() }
+        jvmSentryEvent.breadcrumbs?.let { breadcrumbs = it.map { it.toKmpBreadcrumb() }.toMutableList() }
+        jvmSentryEvent.tags?.let { tags = it }
+    }
+}

sentry-kotlin-multiplatform/src/commonJvmMain/kotlin/io/sentry/kotlin/multiplatform/TypeAliases.kt

@@ -3,9 +3,13 @@ package io.sentry.kotlin.multiplatform
 import io.sentry.Attachment
 import io.sentry.Breadcrumb
 import io.sentry.Scope
+import io.sentry.SentryEvent
 import io.sentry.SentryLevel
 import io.sentry.SentryOptions
 import io.sentry.UserFeedback
+import io.sentry.protocol.Contexts
+import io.sentry.protocol.Message
+import io.sentry.protocol.SentryException
 import io.sentry.protocol.SentryId
 import io.sentry.protocol.User
 
@@ -17,3 +21,7 @@ internal typealias JvmSentryId = SentryId
 internal typealias JvmSentryOptions = SentryOptions
 internal typealias JvmAttachment = Attachment
 internal typealias JvmUserFeedback = UserFeedback
+internal typealias JvmSentryEvent = SentryEvent
+internal typealias JvmMessage = Message
+internal typealias JvmSentryException = SentryException
+internal typealias JvmContexts = Contexts

sentry-kotlin-multiplatform/src/commonJvmMain/kotlin/io/sentry/kotlin/multiplatform/extensions/MessageExtensions.kt

@@ -0,0 +1,17 @@
+package io.sentry.kotlin.multiplatform.extensions
+
+import io.sentry.kotlin.multiplatform.JvmMessage
+import io.sentry.kotlin.multiplatform.protocol.Message
+
+internal fun JvmMessage.toKmpMessage() = Message(
+    message = message,
+    params = params,
+    formatted = formatted
+)
+
+internal fun Message.toJvmMessage() = JvmMessage().apply {
+    val scope = this@toJvmMessage
+    message = scope.message
+    params = scope.params
+    formatted = scope.formatted
+}

sentry-kotlin-multiplatform/src/commonJvmMain/kotlin/io/sentry/kotlin/multiplatform/extensions/SentryEventExtensions.kt

@@ -0,0 +1,22 @@
+package io.sentry.kotlin.multiplatform.extensions
+
+import io.sentry.kotlin.multiplatform.JvmSentryEvent
+import io.sentry.kotlin.multiplatform.JvmSentryId
+import io.sentry.kotlin.multiplatform.SentryEvent
+
+internal fun JvmSentryEvent.applyKmpEvent(kmpEvent: SentryEvent): JvmSentryEvent {
+    level = kmpEvent.level?.toJvmSentryLevel()
+    message = kmpEvent.message?.toJvmMessage()
+    logger = kmpEvent.logger
+    fingerprints = kmpEvent.fingerprint
+    release = kmpEvent.release
+    environment = kmpEvent.environment
+    platform = kmpEvent.platform
+    user = kmpEvent.user?.toJvmUser()
+    serverName = kmpEvent.serverName
+    dist = kmpEvent.dist
+    breadcrumbs = kmpEvent.breadcrumbs?.map { it.toJvmBreadcrumb() }
+    eventId = JvmSentryId(kmpEvent.eventId.toString())
+    tags = kmpEvent.tags
+    return this
+}

sentry-kotlin-multiplatform/src/commonJvmMain/kotlin/io/sentry/kotlin/multiplatform/extensions/SentryExceptionExtensions.kt

@@ -0,0 +1,11 @@
+package io.sentry.kotlin.multiplatform.extensions
+
+import io.sentry.kotlin.multiplatform.JvmSentryException
+import io.sentry.kotlin.multiplatform.protocol.SentryException
+
+internal fun JvmSentryException.toKmpSentryException() = SentryException(
+    type = type,
+    value = value,
+    module = module,
+    threadId = threadId
+)