Merge pull request #2 from EndlessCodeGroup/feature/update-sentry

Update Sentry to 4.0.0-beta.1

Author: osipxd

buildSrc/src/main/kotlin/commons.gradle.kts

@@ -18,7 +18,6 @@ repositories {
 
 dependencies {
     "implementation"(kotlin("stdlib-jdk8"))
-    "implementation"("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.2")
 }
 
 tasks.withType<KotlinCompile>().configureEach {

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-api/build.gradle.kts

@@ -2,3 +2,7 @@
 plugins {
     `bintray-publish`
 }
+
+dependencies {
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.2")
+}

inspector-api/src/main/kotlin/report/ReportEnvironment.kt

@@ -4,13 +4,19 @@ public interface ReportEnvironment {
 
     public companion object {
         public val EMPTY: ReportEnvironment = object : ReportEnvironment {
+            override val appName: String = ""
             override val appVersion: String = ""
             override val reporterId: String = ""
             override val fields: Map<String, ReportField> = emptyMap()
             override val isInspectorEnabled: Boolean = false
         }
     }
 
+    /**
+     * Name of app that uses Inspector.
+     */
+    public val appName: String
+
     /**
      * Version of app that uses Inspector.
      */

inspector-bukkit/build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
 }
 
 bukkit {
-    version = "1.16.4"
+    apiVersion = "1.16.4"
 
     meta {
         name.set("Inspector")

inspector-bukkit/src/main/kotlin/InspectorPlugin.kt

@@ -14,7 +14,7 @@ public class InspectorPlugin : JavaPlugin() {
         logger.severe("")
         logger.severe("What to do?")
         logger.severe("  Please report about it to author of the plugin, that requires Inspector.")
-        logger.severe("  He must bundle it to the plugin or you can use Inspector v0.6.0.")
+        logger.severe("  He should bundle it to the plugin.")
         logger.severe("")
 
         throw AuthorNagException("Aggrh!!! Throwing an exception is only one possible way to disable plugin in onLoad()")

inspector-bukkit/src/main/kotlin/report/BukkitEnvironment.kt

@@ -25,6 +25,7 @@ public class BukkitEnvironment internal constructor(
 
     public val inspector: Inspector = Inspector(plugin, properties.configName)
 
+    override val appName: String = plugin.description.name
     override val appVersion: String = plugin.description.version
     override val reporterId: String = inspector.serverId.toString()
 

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

@@ -1,126 +1,97 @@
 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.Integration
 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,
+    integrations: List<Integration>,
     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.appName}@${focus.environment.appVersion}"
+            options.addInAppInclude(focus.focusedPackage)
+            options.enableUncaughtExceptionHandler = false
+            integrations.forEach(options::addIntegration)
+        }
 
-            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()
+        private val integrations = mutableListOf<Integration>()
 
         /**
-         * 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,8 +102,12 @@ public class SentryReporter private constructor(
                 append(projectId)
             }
 
-            this.options = options
+            return setDsn(dsn)
+        }
 
+        /** Adds given [integration] to Sentry. */
+        public fun addIntegration(integration: Integration): Builder {
+            this.integrations.add(integration)
             return this
         }
 
@@ -141,21 +116,12 @@ public class SentryReporter private constructor(
          */
         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,
+                integrations = integrations,
                 focus = focus,
                 fields = fields
             )

…/java/com/example/myplugin/Myplugin.java …/java/com/example/myplugin/MyPlugin.javasamples/hello-maven/src/main/java/com/example/myplugin/Myplugin.java renamed to samples/hello-maven/src/main/java/com/example/myplugin/MyPlugin.java samples/hello-maven/src/main/java/com/example/myplugin/Myplugin.java renamed to samples/hello-maven/src/main/java/com/example/myplugin/MyPlugin.java

@@ -1,23 +1,23 @@
 plugins {
-    id 'ru.endlesscode.bukkitgradle' version '0.8.2'
-    id 'com.github.johnrengelman.shadow' version '5.2.0'
+    id 'ru.endlesscode.bukkitgradle' version '0.9.2'
+    id 'com.github.johnrengelman.shadow' version '6.1.0'
 }
 
-group = "com.example"
+group = "com.example.myplugin"
 description = "My Bukkit plugin with Sentry Reporter"
 version = "0.1-SNAPSHOT"
 
 // Read more about BukkitGradle: https://github.com/EndlessCodeGroup/BukkitGradle
 bukkit {
-    version = "1.15.1"
+    apiVersion = "1.16.4"
 
     meta {
-        name = "MyPlugin"
-        url = "http://www.example.com"
-        authors = ["osipxd"]
+        name.set("MyPlugin")
+        url.set("http://www.example.com")
+        authors.set(["osipxd"])
     }
 
-    run {
+    server {
         core = "spigot"
         eula = true
     }
@@ -37,13 +37,13 @@ shadowJar {
 }
 tasks.assemble.dependsOn tasks.shadowJar
 
-ext.inspectorVerson = "0.9"
+def inspectorVersion = "0.10.0"
 
 dependencies {
-    compileOnly(bukkit()) { transitive = false }
-    implementation("ru.endlesscode.inspector:inspector-bukkit:$inspectorVerson")
-    implementation("ru.endlesscode.inspector:inspector-sentry-reporter:$inspectorVerson")
-    implementation("ru.endlesscode.inspector:sentry-bukkit:$inspectorVerson")
+    compileOnly(spigotApi()) { transitive = false }
+    implementation("ru.endlesscode.inspector:inspector-bukkit:$inspectorVersion")
+    implementation("ru.endlesscode.inspector:inspector-sentry-reporter:$inspectorVersion")
+    implementation("ru.endlesscode.inspector:sentry-bukkit:$inspectorVersion")
 }
 
 repositories {