refactor: Update Sentry and rewrite integrations

Author: osipxd

buildSrc/src/main/kotlin/dependencies.kt

@@ -1,6 +1,6 @@
 @file:Suppress("ClassName")
 
-const val sentry = "io.sentry:sentry:1.7.29"
+const val sentry = "io.sentry:sentry:4.0.0-beta.1"
 
 object fuel {
     private const val group = "com.github.kittinunf.fuel"

inspector-sentry-reporter/src/main/kotlin/SentryReporter.kt

@@ -1,126 +1,93 @@
 package ru.endlesscode.inspector.report
 
-import io.sentry.DefaultSentryClientFactory
-import io.sentry.DefaultSentryClientFactory.IN_APP_FRAMES_OPTION
-import io.sentry.DefaultSentryClientFactory.UNCAUGHT_HANDLER_ENABLED_OPTION
 import io.sentry.Sentry
-import io.sentry.SentryClientFactory
-import io.sentry.connection.EventSendCallback
-import io.sentry.event.Event
-import io.sentry.event.EventBuilder
-import io.sentry.event.UserBuilder
-import io.sentry.event.interfaces.ExceptionInterface
-import java.util.*
+import io.sentry.SentryEvent
+import io.sentry.protocol.Message
+import io.sentry.protocol.User
 
 /**
  * Reporter that sends reports to Sentry.
  */
 public class SentryReporter private constructor(
     dsn: String,
-    factory: SentryClientFactory,
     override val focus: ReporterFocus,
     private val fields: Set<ReportField>,
 ) : Reporter {
 
     override var enabled: Boolean = true
 
-    private val sentry = Sentry.init(dsn, factory)
-
     private val handlers = CompoundReportHandler()
-    private val pendingExceptions = mutableMapOf<UUID, ExceptionData>()
 
     init {
-        sentry.addEventSendCallback(object : EventSendCallback {
-            override fun onSuccess(event: Event) {
-                val reportedException = removePendingException(event.id)
-                if (reportedException != null) {
-                    handlers.onSuccess(event.message, reportedException)
-                }
-            }
+        Sentry.init { options ->
+            options.dsn = dsn
+            options.release = focus.environment.appVersion
+            options.addInAppInclude(focus.focusedPackage)
+            options.enableUncaughtExceptionHandler = false
+        }
 
-            override fun onFailure(event: Event, exception: Exception) {
-                val isErrorReport = removePendingException(event.id) != null
-                if (isErrorReport) {
-                    handlers.onError(exception)
-                }
+        Sentry.configureScope { scope ->
+            scope.user = User().apply {
+                id = focus.environment.reporterId
             }
-        })
-
-        sentry.release = focus.environment.appVersion
-        sentry.context.user = UserBuilder()
-            .setId(focus.environment.reporterId)
-            .build()
+        }
     }
 
     override fun addHandler(handler: ReportHandler) {
         handlers.addHandler(handler)
     }
 
     override fun report(message: String, exception: Exception, async: Boolean) {
-        val exceptionData = ExceptionData(exception)
-        handlers.beforeReport(message, exceptionData)
-
-        val eventBuilder = EventBuilder()
-            .withMessage(message)
-            .withSentryInterface(ExceptionInterface(exception))
-            .apply {
-                fields.asSequence()
-                    .filter(ReportField::show)
-                    .forEach { withExtra(it.name, it.value) }
-            }
+        val sentryMessage = Message().apply {
+            formatted = message
+        }
 
-        sentry.sendEvent(eventBuilder)
-        addPendingException(sentry.context.lastEventId, exceptionData)
-    }
+        val event = SentryEvent(exception).apply {
+            setMessage(sentryMessage)
+            fields.asSequence()
+                .filter(ReportField::show)
+                .forEach { setExtra(it.name, it.value) }
+        }
+        Sentry.captureEvent(event)
 
-    private fun addPendingException(id: UUID, exception: ExceptionData) {
-        pendingExceptions[id] = exception
+        // We can't track errors on error sending. So we just assume that report was sent successfully.
+        val exceptionData = ExceptionData(exception)
+        handlers.onSuccess(message, exceptionData)
     }
 
-    private fun removePendingException(id: UUID): ExceptionData? = pendingExceptions.remove(id)
-
     /**
      * Builder that should be used to build [SentryReporter].
      *
      * You should specify DSN with one of [setDataSourceName] methods.
      */
     public class Builder : Reporter.Builder() {
 
-        private var clientFactory: SentryClientFactory? = null
         private var dsn: String = ""
-        private var options: Map<String, String> = emptyMap()
 
         /**
-         * Set [SentryClientFactory], that will be used to create SentryClient.
+         * Set Sentry [dsn].
+         * See: [Setting the DSN](https://docs.sentry.io/clients/java/config/#setting-the-dsn)
          */
-        public fun setClientFactory(clientFactory: SentryClientFactory): Builder {
-            this.clientFactory = clientFactory
+        public fun setDsn(dsn: String): Builder {
+            this.dsn = dsn
             return this
         }
 
-        /**
-         * Set Sentry [dsn] with one string.
-         * See: https://docs.sentry.io/clients/java/config/#setting-the-dsn
-         */
+        @Deprecated("Use setDsn", ReplaceWith("setDsn(dsn)"))
         public fun setDataSourceName(dsn: String): Builder {
-            this.dsn = dsn
-            return this
+            return setDsn(dsn)
         }
 
-        /**
-         * Set Sentry [dsn] built from separated parts.
-         * See: https://docs.sentry.io/clients/java/config/#setting-the-dsn
-         */
         @JvmOverloads
+        @Deprecated("Use setDsn")
         public fun setDataSourceName(
             publicKey: String,
             projectId: String,
             protocol: String = "https",
             host: String = "sentry.io",
             port: String = "",
-            options: Map<String, String> = emptyMap(),
         ): Builder {
-            this.dsn = buildString {
+            val dsn = buildString {
                 append(protocol)
                 append("://")
                 append(publicKey)
@@ -131,31 +98,19 @@ public class SentryReporter private constructor(
                 append(projectId)
             }
 
-            this.options = options
-
-            return this
+            return setDsn(dsn)
         }
 
         /**
          * Build configured [SentryReporter].
          */
         override fun build(): Reporter {
             require(dsn.isNotBlank()) {
-                "You should specify DSN with method `setDataSourceName(...)` and it shouldn't be blank."
+                "You should specify DSN with method `setDsn(...)` and it shouldn't be blank."
             }
 
-            val options = mutableMapOf(
-                IN_APP_FRAMES_OPTION to focus.focusedPackage,
-                UNCAUGHT_HANDLER_ENABLED_OPTION to "false"
-            )
-            options.putAll(this.options)
-
-            val optionsString = options.asSequence()
-                .joinToString(prefix = "?", separator = "&") { (key, value) -> "$key=$value" }
-
             return SentryReporter(
-                dsn = "$dsn$optionsString",
-                factory = clientFactory ?: DefaultSentryClientFactory(),
+                dsn = dsn,
                 focus = focus,
                 fields = fields
             )

sentry-bukkit/src/main/kotlin/BukkitPluginSentryClientFactory.kt

@@ -0,0 +1,47 @@
+package ru.endlesscode.inspector.sentry.bukkit
+
+import io.sentry.IHub
+import io.sentry.Integration
+import io.sentry.SentryOptions
+import org.bukkit.Server
+import org.bukkit.plugin.Plugin
+
+/**
+ * SentryClientFactory that handles Bukkit-specific construction, like logging
+ * server and plugin information.
+ */
+public class SentryBukkitIntegration(private val plugin: Plugin) : Integration {
+
+    public companion object {
+        private val KNOWN_SERVERS = listOf("Paper", "Spigot", "CraftBukkit", "BungeeCord", "WaterFall")
+    }
+
+    private val Server.knownName: String
+        get() = (KNOWN_SERVERS.find { it in version } ?: "Unknown").toLowerCase()
+    private val Server.minecraftVersion: String
+        get() = bukkitVersion.substringBefore('-')
+
+    override fun register(hub: IHub, options: SentryOptions) {
+        options.sdkVersion?.addIntegration("bukkit")
+        options.serverName = plugin.server.knownName
+        options.setTag("minecraft", plugin.server.minecraftVersion)
+        options.setBeforeSend { event, _ ->
+            event.contexts.putAll(getContexts())
+            event
+        }
+    }
+
+    private fun getContexts(): Map<String, Map<String, Any>> {
+        val serverMap = mapOf(
+            "Name" to plugin.server.knownName,
+            "Version" to plugin.server.version,
+            "Minecraft Version" to plugin.server.minecraftVersion
+        )
+        val pluginMap = mapOf(
+            "Name" to plugin.description.name,
+            "Version" to plugin.description.version,
+            "API Version" to plugin.description.apiVersion.toString()
+        )
+        return mapOf("server" to serverMap, "plugin" to pluginMap)
+    }
+}