GH-394 Add Sentry integration

buildSrc/src/main/kotlin/Versions.kt

@@ -42,6 +42,8 @@ object Versions {
 
     const val SPOTIFY_COMPLETABLE_FUTURES = "0.3.6"
 
+    const val SENTRY = "8.0.0-alpha.2"
+
     // tests
     const val EXPRESSIBLE_JUNIT = "1.3.6"
     const val GROOVY_ALL = "3.0.21"

eternalcore-core/build.gradle.kts

@@ -97,4 +97,8 @@ eternalShadow {
     // caffeine
     library("com.github.ben-manes.caffeine:caffeine:${Versions.CAFFEINE}")
     libraryRelocate("com.github.benmanes.caffeine");
+
+    // sentry
+    library("io.sentry:sentry:${Versions.SENTRY}")
+    libraryRelocate("io.sentry")
 }

eternalcore-core/src/main/java/com/eternalcode/core/EternalCore.java

@@ -13,6 +13,7 @@
 import com.eternalcode.core.publish.Publisher;
 import com.eternalcode.core.publish.event.EternalInitializeEvent;
 import com.eternalcode.core.publish.event.EternalShutdownEvent;
+import io.sentry.Sentry;
 import net.dzikoysk.cdn.entity.Contextual;
 import org.bukkit.Server;
 import org.bukkit.plugin.Plugin;

eternalcore-core/src/main/java/com/eternalcode/core/bridge/litecommand/LiteCommandsSetup.java

@@ -1,5 +1,6 @@
 package com.eternalcode.core.bridge.litecommand;
 
+import com.eternalcode.core.bridge.sentry.SentryLiteCommandExceptionHandler;
 import com.eternalcode.core.injector.annotations.Bean;
 import com.eternalcode.core.injector.annotations.component.BeanSetup;
 import com.eternalcode.core.injector.bean.BeanFactory;
@@ -33,7 +34,8 @@ class LiteCommandsSetup implements Subscriber {
             .commands(liteCommandsAnnotations)
             .extension(new LiteAdventurePlatformExtension<CommandSender>(audiencesProvider), extension -> extension
                 .serializer(miniMessage)
-            );
+            )
+            .exception(Throwable.class, new SentryLiteCommandExceptionHandler());
     }
 
     @Bean

eternalcore-core/src/main/java/com/eternalcode/core/bridge/litecommand/argument/DurationArgument.java

@@ -11,11 +11,12 @@
 import dev.rollczi.litecommands.invocation.Invocation;
 import dev.rollczi.litecommands.suggestion.SuggestionContext;
 import dev.rollczi.litecommands.suggestion.SuggestionResult;
+import org.bukkit.command.CommandSender;
+
 import java.time.Duration;
 import java.time.format.DateTimeParseException;
 import java.util.Arrays;
 import java.util.List;
-import org.bukkit.command.CommandSender;
 
 @LiteArgument(type = Duration.class)
 class DurationArgument extends AbstractViewerArgument<Duration> {

eternalcore-core/src/main/java/com/eternalcode/core/bridge/sentry/SentryLiteCommandExceptionHandler.java

@@ -0,0 +1,15 @@
+package com.eternalcode.core.bridge.sentry;
+
+import dev.rollczi.litecommands.handler.exception.ExceptionHandler;
+import dev.rollczi.litecommands.handler.result.ResultHandlerChain;
+import dev.rollczi.litecommands.invocation.Invocation;
+import io.sentry.Sentry;
+import org.bukkit.command.CommandSender;
+
+public class SentryLiteCommandExceptionHandler implements ExceptionHandler<CommandSender, Throwable> {
+
+    @Override
+    public void handle(Invocation<CommandSender> invocation, Throwable t, ResultHandlerChain<CommandSender> resultHandlerChain) {
+        Sentry.captureException(t);
+    }
+}

eternalcore-core/src/main/java/com/eternalcode/core/bridge/sentry/SentrySetup.java

@@ -0,0 +1,88 @@
+package com.eternalcode.core.bridge.sentry;
+
+import com.eternalcode.core.configuration.implementation.PluginConfiguration;
+import com.eternalcode.core.injector.DependencyInjectorException;
+import com.eternalcode.core.injector.annotations.Inject;
+import com.eternalcode.core.injector.annotations.component.BeanSetup;
+import com.eternalcode.core.injector.bean.BeanException;
+import com.eternalcode.core.publish.Subscribe;
+import com.eternalcode.core.publish.Subscriber;
+import com.eternalcode.core.publish.event.EternalInitializeEvent;
+import com.google.common.collect.ImmutableList;
+import dev.rollczi.litecommands.LiteCommandsException;
+import io.papermc.lib.PaperLib;
+import io.sentry.Sentry;
+import org.bukkit.Server;
+import org.bukkit.plugin.Plugin;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.ParserConfigurationException;
+import java.net.MalformedURLException;
+import java.nio.file.FileSystemException;
+import java.sql.SQLException;
+import java.time.format.DateTimeParseException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+@BeanSetup
+class SentrySetup implements Subscriber {
+
+    private static final List<Class<? extends Throwable>> LOADER_OR_INJECTOR_EXCEPTIONS = List.of(
+        ReflectiveOperationException.class,
+        FileSystemException.class,
+        SAXException.class,
+        BeanException.class,
+        NoClassDefFoundError.class,
+        MalformedURLException.class,
+        ParserConfigurationException.class,
+        DependencyInjectorException.class
+    );
+
+    private static final List<Class<? extends Throwable>> DATABASE_EXCEPTIONS = ImmutableList.of(
+        SQLException.class,
+        ExecutionException.class
+    );
+
+    private static final List<Class<? extends Throwable>> LITECOMMANDS_EXCEPTIONS = ImmutableList.of(
+        LiteCommandsException.class,
+        DateTimeParseException.class
+    );
+
+
+    private final PluginConfiguration config;
+
+    @Inject
+    SentrySetup(PluginConfiguration config) {
+        this.config = config;
+    }
+
+    @Subscribe(EternalInitializeEvent.class)
+    public void onInitialize(Plugin plugin, Server server) {
+        if (this.config.sentryEnabled) {
+            Sentry.init(options -> {
+                options.setDsn("https://4bf366d0d9f1da00162b9e629a80be52@o4505014505177088.ingest.us.sentry.io/4506093905051648");
+                options.setTracesSampleRate(0.75);
+                options.setRelease(plugin.getDescription().getVersion());
+                options.setEnvironment(PaperLib.getEnvironment().getName());
+                options.setTag("plugins", Arrays.stream(server.getPluginManager().getPlugins()).toList().toString());
+                options.setTag("serverVersion", server.getVersion());
+                options.setBeforeSend((event, hint) -> {
+                    Throwable throwable = event.getThrowable();
+
+                    if (throwable != null) {
+                        if (LOADER_OR_INJECTOR_EXCEPTIONS.stream().anyMatch(exception -> exception.isInstance(throwable))) {
+                            event.setFingerprints(List.of("loader_or_injector"));
+                        } else if (DATABASE_EXCEPTIONS.stream().anyMatch(exception -> exception.isInstance(throwable))) {
+                            event.setFingerprints(List.of("database"));
+                        } else if (LITECOMMANDS_EXCEPTIONS.stream().anyMatch(exception -> exception.isInstance(throwable))) {
+                            event.setFingerprints(List.of("litecommands"));
+                        }
+                    }
+
+                    return event;
+                });
+            });
+        }
+    }
+}

eternalcore-core/src/main/java/com/eternalcode/core/configuration/implementation/PluginConfiguration.java

@@ -6,15 +6,13 @@
 import com.eternalcode.core.feature.afk.AfkSettings;
 import com.eternalcode.core.feature.automessage.AutoMessageSettings;
 import com.eternalcode.core.feature.chat.ChatSettings;
+import com.eternalcode.core.feature.helpop.HelpOpSettings;
 import com.eternalcode.core.feature.jail.JailSettings;
 import com.eternalcode.core.feature.randomteleport.RandomTeleportSettings;
 import com.eternalcode.core.feature.randomteleport.RandomTeleportType;
-import com.eternalcode.core.feature.helpop.HelpOpSettings;
 import com.eternalcode.core.feature.spawn.SpawnSettings;
-import com.eternalcode.core.injector.annotations.component.ConfigurationFile;
 import com.eternalcode.core.feature.teleportrequest.TeleportRequestSettings;
-import java.util.LinkedHashMap;
-import java.util.Set;
+import com.eternalcode.core.injector.annotations.component.ConfigurationFile;
 import net.dzikoysk.cdn.entity.Contextual;
 import net.dzikoysk.cdn.entity.Description;
 import net.dzikoysk.cdn.entity.Exclude;
@@ -25,7 +23,9 @@
 
 import java.io.File;
 import java.time.Duration;
+import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Set;
 
 @ConfigurationFile
 public class PluginConfiguration implements ReloadableConfig {
@@ -43,6 +43,10 @@ public class PluginConfiguration implements ReloadableConfig {
         "#",
     })
 
+    @Description({ "", "# Whether Sentry - the real-time error tracking system should be enabled",
+        "# We strongly recommend leaving this option on true, as it helps us fixing bugs faster."})
+    public boolean sentryEnabled = true;
+
     @Description("# Whether the player should receive information about new plugin updates upon joining the server")
     public boolean shouldReceivePluginUpdates = true;
 

eternalcore-core/src/main/java/com/eternalcode/core/database/DatabaseManager.java

@@ -8,6 +8,7 @@
 import com.j256.ormlite.jdbc.DataSourceConnectionSource;
 import com.j256.ormlite.support.ConnectionSource;
 import com.zaxxer.hikari.HikariDataSource;
+import io.sentry.Sentry;
 
 import java.io.File;
 import java.sql.SQLException;
@@ -95,6 +96,7 @@ public void close() {
             this.connectionSource.close();
         }
         catch (Exception exception) {
+            Sentry.captureException(exception);
             exception.printStackTrace();
         }
     }
@@ -112,6 +114,7 @@ public <T, ID> Dao<T, ID> getDao(Class<T> type) {
             return (Dao<T, ID>) dao;
         }
         catch (SQLException exception) {
+            Sentry.captureException(exception);
             throw new RuntimeException(exception);
         }
     }

eternalcore-core/src/main/java/com/eternalcode/core/database/DatabaseManagerSetup.java

@@ -1,11 +1,12 @@
 package com.eternalcode.core.database;
 
 import com.eternalcode.core.configuration.implementation.PluginConfiguration;
-import com.eternalcode.core.publish.Subscriber;
-import com.eternalcode.core.publish.event.EternalShutdownEvent;
 import com.eternalcode.core.injector.annotations.Bean;
 import com.eternalcode.core.injector.annotations.component.BeanSetup;
 import com.eternalcode.core.publish.Subscribe;
+import com.eternalcode.core.publish.Subscriber;
+import com.eternalcode.core.publish.event.EternalShutdownEvent;
+import io.sentry.Sentry;
 
 import java.io.File;
 import java.sql.SQLException;
@@ -22,6 +23,7 @@ DatabaseManager databaseManager(PluginConfiguration pluginConfiguration, Logger
             databaseManager.connect();
         }
         catch (SQLException exception) {
+            Sentry.captureException(exception);
             logger.severe("Could not connect to database! Some functions may not work properly!");
             throw new RuntimeException(exception);
         }

eternalcore-core/src/main/java/com/eternalcode/core/database/wrapper/AbstractRepositoryOrmLite.java

@@ -3,6 +3,7 @@
 import com.eternalcode.commons.scheduler.Scheduler;
 import com.eternalcode.core.database.DatabaseManager;
 import com.j256.ormlite.dao.Dao;
+import io.sentry.Sentry;
 import panda.std.function.ThrowingFunction;
 
 import java.sql.SQLException;
@@ -62,6 +63,7 @@ protected <T, ID, R> CompletableFuture<R> action(Class<T> type, ThrowingFunction
                 completableFuture.complete(action.apply(dao));
             }
             catch (Throwable throwable) {
+                Sentry.captureException(throwable);
                 completableFuture.completeExceptionally(throwable);
             }
         });

eternalcore-core/src/main/java/com/eternalcode/core/feature/essentials/mob/ButcherArgument.java

@@ -4,12 +4,12 @@
 import com.eternalcode.core.configuration.implementation.PluginConfiguration;
 import com.eternalcode.core.injector.annotations.Inject;
 import com.eternalcode.core.injector.annotations.lite.LiteArgument;
-import com.eternalcode.multification.notice.NoticeBroadcast;
 import com.eternalcode.core.notice.NoticeService;
 import com.eternalcode.core.translation.Translation;
 import com.eternalcode.core.translation.TranslationManager;
 import com.eternalcode.core.viewer.Viewer;
 import com.eternalcode.core.viewer.ViewerService;
+import com.eternalcode.multification.notice.NoticeBroadcast;
 import dev.rollczi.litecommands.argument.Argument;
 import dev.rollczi.litecommands.argument.parser.ParseResult;
 import dev.rollczi.litecommands.invocation.Invocation;

eternalcore-core/src/main/java/com/eternalcode/core/feature/ignore/IgnoreRepositoryOrmLite.java

@@ -13,6 +13,7 @@
 import com.j256.ormlite.stmt.DeleteBuilder;
 import com.j256.ormlite.table.DatabaseTable;
 import com.j256.ormlite.table.TableUtils;
+import io.sentry.Sentry;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
@@ -53,6 +54,7 @@ public CompletableFuture<Boolean> isIgnored(UUID by, UUID target) {
                 return uuids.contains(target) || uuids.contains(IGNORE_ALL);
             }
             catch (ExecutionException exception) {
+                Sentry.captureException(exception);
                 throw new RuntimeException(exception);
             }
         });
@@ -70,6 +72,7 @@ public CompletableFuture<Void> ignore(UUID by, UUID target) {
                 }
             }
             catch (ExecutionException exception) {
+                Sentry.captureException(exception);
                 throw new RuntimeException(exception);
             }
         });

eternalcore-core/src/main/java/com/eternalcode/core/injector/DependencyInjector.java

@@ -2,6 +2,7 @@
 
 import com.eternalcode.core.injector.annotations.Inject;
 import com.eternalcode.core.injector.bean.BeanException;
+import io.sentry.Sentry;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
@@ -47,9 +48,11 @@ public Object invokeMethod(Object instance, Method method, Object... additionalD
             return method.invoke(instance, parameters);
         }
         catch (BeanException beanException) {
+    Sentry.captureException(beanException);
             throw new DependencyInjectorException("Failed to invoke method " + method.getName() + " in " + declaringClass.getName() + "!", beanException, declaringClass);
         }
         catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException exception) {
+            Sentry.captureException(exception);
             throw new DependencyInjectorException(exception, declaringClass);
         }
     }
@@ -85,9 +88,11 @@ private <T> T newInstance(Constructor<T> constructor, Object... additionalDepend
             return constructor.newInstance(parameters);
         }
         catch (BeanException beanException) {
+            Sentry.captureException(beanException);
             throw new DependencyInjectorException("Failed to create a new instance of " + declaringClass.getName() + "!", beanException, declaringClass);
         }
         catch (InvocationTargetException | InstantiationException | IllegalAccessException exception) {
+            Sentry.captureException(exception);
             throw new DependencyInjectorException(exception, declaringClass);
         }
     }

eternalcore-core/src/main/java/com/eternalcode/core/injector/bean/LazyFieldBeanCandidate.java

@@ -1,5 +1,7 @@
 package com.eternalcode.core.injector.bean;
 
+import io.sentry.Sentry;
+
 import java.lang.reflect.Field;
 
 public class LazyFieldBeanCandidate extends LazyBeanCandidate {
@@ -15,7 +17,10 @@ public LazyFieldBeanCandidate(Object instance, Field field) {
                 return field.get(instance);
             }
             catch (IllegalAccessException exception) {
-                throw new BeanException("Cannot access field " + field.getName() + " of " + instance.getClass().getName(), exception, field.getType());
+                String message = "Cannot access field " + field.getName() + " of " + instance.getClass().getName();
+                Sentry.captureException(exception);
+                Sentry.captureMessage(message);
+                throw new BeanException(message, exception, field.getType());
             }
         });
         this.field = field;

eternalcore-core/src/main/java/com/eternalcode/core/util/ReflectUtil.java

@@ -2,6 +2,7 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.reflect.ClassPath;
+import io.sentry.Sentry;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -45,6 +46,7 @@ public static List<Class<?>> scanClasses(String packageToScan, ClassLoader class
             return loadedClasses;
         }
         catch (IOException | ClassNotFoundException exception) {
+    Sentry.captureException(exception);
             throw new RuntimeException(exception);
         }
     }

eternalcore-docs-api/build.gradle.kts

@@ -7,4 +7,6 @@ dependencies {
     compileOnly("com.google.guava:guava:${Versions.GUAVA}")
     compileOnly("com.google.code.gson:gson:${Versions.GSON}")
     compileOnly("dev.rollczi:litecommands-framework:${Versions.LITE_COMMANDS}")
+
+    implementation("io.sentry:sentry:${Versions.SENTRY}")
 }