Leaf/patches/server/0006-Pufferfish-Sentry.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Kevin Raneri <kevin.raneri@gmail.com>
Date: Tue, 9 Nov 2021 14:08:14 -0500
Subject: [PATCH] Pufferfish: Sentry

Original license: GPL v3
Original project: https://github.com/pufferfish-gg/Pufferfish

diff --git a/src/main/java/gg/pufferfish/pufferfish/sentry/PufferfishSentryAppender.java b/src/main/java/gg/pufferfish/pufferfish/sentry/PufferfishSentryAppender.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d1d6751cb6e9d6f282d343b58a80ca8640e259a
--- /dev/null
+++ b/src/main/java/gg/pufferfish/pufferfish/sentry/PufferfishSentryAppender.java
@@ -0,0 +1,133 @@
+package gg.pufferfish.pufferfish.sentry;
+
+import com.google.common.reflect.TypeToken;
+import com.google.gson.Gson;
+import io.sentry.Breadcrumb;
+import io.sentry.Sentry;
+import io.sentry.SentryEvent;
+import io.sentry.SentryLevel;
+import io.sentry.protocol.Message;
+import io.sentry.protocol.User;
+
+import java.util.Map;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Marker;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.filter.AbstractFilter;
+import org.dreeam.leaf.config.modules.misc.SentryDSN;
+
+public class PufferfishSentryAppender extends AbstractAppender {
+
+    private static final org.apache.logging.log4j.Logger logger = LogManager.getLogger(PufferfishSentryAppender.class.getSimpleName());
+    private static final Gson GSON = new Gson();
+    private final Level logLevel;
+
+    public PufferfishSentryAppender(Level logLevel) {
+        super("PufferfishSentryAdapter", new SentryFilter(), null);
+        this.logLevel = logLevel;
+    }
+
+    @Override
+    public void append(LogEvent logEvent) {
+        if (logEvent.getLevel().isMoreSpecificThan(logLevel) && (logEvent.getThrown() != null || !SentryDSN.onlyLogThrown)) {
+            try {
+                logException(logEvent);
+            } catch (Exception e) {
+                logger.warn("Failed to log event with sentry", e);
+            }
+        } else {
+            try {
+                logBreadcrumb(logEvent);
+            } catch (Exception e) {
+                logger.warn("Failed to log event with sentry", e);
+            }
+        }
+    }
+
+    private void logException(LogEvent e) {
+        SentryEvent event = new SentryEvent(e.getThrown());
+
+        Message sentryMessage = new Message();
+        sentryMessage.setMessage(e.getMessage().getFormattedMessage());
+
+        event.setThrowable(e.getThrown());
+        event.setLevel(getLevel(e.getLevel()));
+        event.setLogger(e.getLoggerName());
+        event.setTransaction(e.getLoggerName());
+        event.setExtra("thread_name", e.getThreadName());
+
+        boolean hasContext = e.getContextData() != null;
+
+        if (hasContext && e.getContextData().containsKey("pufferfishsentry_playerid")) {
+            User user = new User();
+            user.setId(e.getContextData().getValue("pufferfishsentry_playerid"));
+            user.setUsername(e.getContextData().getValue("pufferfishsentry_playername"));
+            event.setUser(user);
+        }
+
+        if (hasContext && e.getContextData().containsKey("pufferfishsentry_pluginname")) {
+            event.setExtra("plugin.name", e.getContextData().getValue("pufferfishsentry_pluginname"));
+            event.setExtra("plugin.version", e.getContextData().getValue("pufferfishsentry_pluginversion"));
+            event.setTransaction(e.getContextData().getValue("pufferfishsentry_pluginname"));
+        }
+
+        if (hasContext && e.getContextData().containsKey("pufferfishsentry_eventdata")) {
+            Map<String, String> eventFields = GSON.fromJson((String) e.getContextData().getValue("pufferfishsentry_eventdata"), new TypeToken<Map<String, String>>() {
+            }.getType());
+            if (eventFields != null) {
+                event.setExtra("event", eventFields);
+            }
+        }
+
+        Sentry.captureEvent(event);
+    }
+
+    private void logBreadcrumb(LogEvent e) {
+        Breadcrumb breadcrumb = new Breadcrumb();
+
+        breadcrumb.setLevel(getLevel(e.getLevel()));
+        breadcrumb.setCategory(e.getLoggerName());
+        breadcrumb.setType(e.getLoggerName());
+        breadcrumb.setMessage(e.getMessage().getFormattedMessage());
+
+        Sentry.addBreadcrumb(breadcrumb);
+    }
+
+    private SentryLevel getLevel(Level level) {
+        return switch (level.getStandardLevel()) {
+            case TRACE, DEBUG -> SentryLevel.DEBUG;
+            case WARN -> SentryLevel.WARNING;
+            case ERROR -> SentryLevel.ERROR;
+            case FATAL -> SentryLevel.FATAL;
+            default -> SentryLevel.INFO;
+        };
+    }
+
+    private static class SentryFilter extends AbstractFilter {
+
+        @Override
+        public Result filter(Logger logger, org.apache.logging.log4j.Level level, Marker marker, String msg,
+                             Object... params) {
+            return this.filter(logger.getName());
+        }
+
+        @Override
+        public Result filter(Logger logger, org.apache.logging.log4j.Level level, Marker marker, Object msg, Throwable t) {
+            return this.filter(logger.getName());
+        }
+
+        @Override
+        public Result filter(LogEvent event) {
+            return this.filter(event == null ? null : event.getLoggerName());
+        }
+
+        private Result filter(String loggerName) {
+            return loggerName != null && loggerName.startsWith("gg.castaway.pufferfish.sentry") ? Result.DENY
+                    : Result.NEUTRAL;
+        }
+    }
+}
diff --git a/src/main/java/gg/pufferfish/pufferfish/sentry/SentryManager.java b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..1fc08518f9cc2b6840b5074f181aefc693c3074b
--- /dev/null
+++ b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryManager.java
@@ -0,0 +1,44 @@
+package gg.pufferfish.pufferfish.sentry;
+
+import io.sentry.Sentry;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class SentryManager {
+
+    private static final Logger logger = LogManager.getLogger(SentryManager.class);
+
+    private SentryManager() {
+
+    }
+
+    private static boolean initialized = false;
+
+    public static synchronized void init(Level logLevel) {
+        if (initialized) {
+            return;
+        }
+        if (logLevel == null) {
+            logger.error("Invalid log level, defaulting to WARN.");
+            logLevel = Level.WARN;
+        }
+        try {
+            initialized = true;
+
+            Sentry.init(options -> {
+                options.setDsn(org.dreeam.leaf.config.modules.misc.SentryDSN.sentryDsn);
+                options.setMaxBreadcrumbs(100);
+            });
+
+            PufferfishSentryAppender appender = new PufferfishSentryAppender(logLevel);
+            appender.start();
+            ((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger()).addAppender(appender);
+            logger.info("Sentry logging started!");
+        } catch (Exception e) {
+            logger.warn("Failed to initialize sentry!", e);
+            initialized = false;
+        }
+    }
+
+}
diff --git a/src/main/java/org/dreeam/leaf/config/LeafConfig.java b/src/main/java/org/dreeam/leaf/config/LeafConfig.java
index fdbdf3f6a5071ce629d2881e861075dbeef11b42..41b24849b6601cdf89ee6cb4125a7127e716c5ee 100644
--- a/src/main/java/org/dreeam/leaf/config/LeafConfig.java
+++ b/src/main/java/org/dreeam/leaf/config/LeafConfig.java
@@ -1,6 +1,7 @@
 package org.dreeam.leaf.config;
 
 import io.papermc.paper.configuration.GlobalConfiguration;
+import org.dreeam.leaf.config.modules.misc.SentryDSN;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 
@@ -211,6 +212,7 @@ public class LeafConfig {
 
     private static String[] buildSparkHiddenPaths() {
         return new String[]{
+                SentryDSN.sentryDsnConfigPath // Hide Sentry DSN key
         };
     }
 
diff --git a/src/main/java/org/dreeam/leaf/config/modules/misc/SentryDSN.java b/src/main/java/org/dreeam/leaf/config/modules/misc/SentryDSN.java
new file mode 100644
index 0000000000000000000000000000000000000000..0234fc0d3054d8348da49a8006ec99d6d09114fe
--- /dev/null
+++ b/src/main/java/org/dreeam/leaf/config/modules/misc/SentryDSN.java
@@ -0,0 +1,43 @@
+package org.dreeam.leaf.config.modules.misc;
+
+import org.apache.logging.log4j.Level;
+import org.dreeam.leaf.config.ConfigModules;
+import org.dreeam.leaf.config.EnumConfigCategory;
+
+public class SentryDSN extends ConfigModules {
+
+    public String getBasePath() {
+        return EnumConfigCategory.MISC.getBaseKeyName() + ".sentry";
+    }
+
+    public static String sentryDsnConfigPath;
+    public static String sentryDsn = "";
+    public static String logLevel = "WARN";
+    public static boolean onlyLogThrown = true;
+
+    @Override
+    public void onLoaded() {
+        String sentryEnvironment = System.getenv("SENTRY_DSN");
+        String sentryConfig = config.getString(sentryDsnConfigPath = getBasePath() + ".dsn", sentryDsn, config.pickStringRegionBased("""
+                Sentry DSN for improved error logging, leave blank to disable,
+                Obtain from https://sentry.io/""",
+                """
+                Sentry DSN (出现严重错误时将发送至配置的Sentry DSN地址) (留空关闭)"""));
+
+        sentryDsn = sentryEnvironment == null
+                ? sentryConfig
+                : sentryEnvironment;
+        logLevel = config.getString(getBasePath() + ".log-level", logLevel, config.pickStringRegionBased("""
+                Logs with a level higher than or equal to this level will be recorded.""",
+                """
+                大于等于该等级的日志会被记录."""));
+        onlyLogThrown = config.getBoolean(getBasePath() + ".only-log-thrown", onlyLogThrown, config.pickStringRegionBased("""
+                Only log with a Throwable will be recorded after enabling this.""",
+                """
+                是否仅记录带有 Throwable 的日志."""));
+
+        if (sentryDsn != null && !sentryDsn.isBlank()) {
+            gg.pufferfish.pufferfish.sentry.SentryManager.init(Level.getLevel(logLevel));
+        }
+    }
+}