added minecraft logging logic and filtering

3 files changed, 196 insertions, 3 deletions

diff --git a/src/main/java/at/hannibal2/skyhanni/utils/LorenzLogger.kt b/src/main/java/at/hannibal2/skyhanni/utils/LorenzLogger.kt
index 22977b468..b748b8676 100644
--- a/src/main/java/at/hannibal2/skyhanni/utils/LorenzLogger.kt
+++ b/src/main/java/at/hannibal2/skyhanni/utils/LorenzLogger.kt
@@ -35,7 +35,7 @@ class LorenzLogger(filePath: String) {
     }
 
     private fun initLogger(): Logger {
-        val logger = Logger.getLogger("" + System.nanoTime())
+        val logger = Logger.getLogger("Lorenz-Logger-" + System.nanoTime())
         try {
             createParent(File(fileName))
             val handler = FileHandler(fileName)
diff --git a/src/main/java/at/hannibal2/skyhanni/utils/LorenzUtils.kt b/src/main/java/at/hannibal2/skyhanni/utils/LorenzUtils.kt
index 602dbad19..b6854a3da 100644
--- a/src/main/java/at/hannibal2/skyhanni/utils/LorenzUtils.kt
+++ b/src/main/java/at/hannibal2/skyhanni/utils/LorenzUtils.kt
@@ -1,7 +1,9 @@
 package at.hannibal2.skyhanni.utils
 
+import at.hannibal2.skyhanni.SkyHanniMod
 import at.hannibal2.skyhanni.data.HypixelData
 import at.hannibal2.skyhanni.features.dungeon.DungeonData
+import at.hannibal2.skyhanni.utils.StringUtils.removeColor
 import net.minecraft.client.Minecraft
 import net.minecraft.entity.EntityLivingBase
 import net.minecraft.entity.SharedMonsterAttributes
@@ -50,13 +52,13 @@ object LorenzUtils {
         log.log(message)
         val minecraft = Minecraft.getMinecraft()
         if (minecraft == null) {
-            println(message)
+            consoleLog(message.removeColor())
             return
         }
 
         val thePlayer = minecraft.thePlayer
         if (thePlayer == null) {
-            println(message)
+            consoleLog(message.removeColor())
             return
         }
 
@@ -103,4 +105,8 @@ object LorenzUtils {
         DecimalFormat(format).format(d).replace(',', 'x').replace('.', ',').replace('x', '.')
 
     fun formatDouble(d: Double): String = formatDouble(d, "#,##0.0")
+
+    fun consoleLog(text: String) {
+        SkyHanniMod.consoleLog(text)
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/at/hannibal2/skyhanni/utils/MinecraftConsoleFilter.kt b/src/main/java/at/hannibal2/skyhanni/utils/MinecraftConsoleFilter.kt
new file mode 100644
index 000000000..0159b4809
--- /dev/null
+++ b/src/main/java/at/hannibal2/skyhanni/utils/MinecraftConsoleFilter.kt
@@ -0,0 +1,187 @@
+package at.hannibal2.skyhanni.utils
+
+import org.apache.logging.log4j.Level
+import org.apache.logging.log4j.LogManager
+import org.apache.logging.log4j.Marker
+import org.apache.logging.log4j.core.Filter
+import org.apache.logging.log4j.core.LogEvent
+import org.apache.logging.log4j.core.Logger
+import org.apache.logging.log4j.core.LoggerContext
+import org.apache.logging.log4j.message.Message
+
+class MinecraftConsoleFilter(private val loggerConfigName: String) : Filter {
+
+    val lorenzLogger = LorenzLogger("debug/mc_console_log")
+
+    var printUnfilteredDebugs = false
+    var printUnfilteredDebugsOutsideSkyBlock = false
+    var printFilteredReason = false
+
+    var filterChat = false
+    var filterGrowBuffer = false
+    var filterUnknownSound = false
+    var filterScoreboardErrors = false
+
+    companion object {
+        @JvmStatic
+        fun initLogging() {
+            val ctx: LoggerContext = LogManager.getContext(false) as LoggerContext
+
+            for (loggerConfig in ctx.configuration.loggers.values) {
+                val loggerName = loggerConfig.name
+                loggerConfig.addFilter(MinecraftConsoleFilter(loggerName))
+            }
+        }
+    }
+
+    override fun filter(event: LogEvent?): Filter.Result {
+//        printUnfilteredDebugs = true
+//        printUnfilteredDebugsOutsideSkyBlock = false
+//        printFilteredReason = false
+//
+//        filterChat = true
+//        filterGrowBuffer = true
+//        filterUnknownSound = true
+//        filterScoreboardErrors = true
+
+        if (event == null) return Filter.Result.ACCEPT
+
+        val loggerName = event.loggerName
+        if (loggerName == "skyhanni") return Filter.Result.ACCEPT
+
+        val message = event.message
+        val formattedMessage = message.formattedMessage
+        val thrown = event.thrown
+
+        if (filterChat) {
+            if (formattedMessage.startsWith("[CHAT] ")) {
+                filterConsole("chat")
+                return Filter.Result.DENY
+            }
+        }
+        if (filterGrowBuffer) {
+            if (formattedMessage.startsWith("Needed to grow BufferBuilder buffer: Old size ")) {
+                filterConsole("Grow BufferBuilder buffer")
+                return Filter.Result.DENY
+            }
+        }
+        if (filterUnknownSound) {
+            if (formattedMessage == "Unable to play unknown soundEvent: minecraft:") {
+                filterConsole("Unknown soundEvent (minecraft:)")
+                return Filter.Result.DENY
+            }
+        }
+        if (thrown != null) {
+            val cause = thrown.cause
+            if (cause != null) {
+                if (cause.stackTrace.isNotEmpty()) {
+                    val first = cause.stackTrace[0]
+                    if (filterScoreboardErrors) {
+                        if (first.toString() == "net.minecraft.scoreboard.Scoreboard.removeTeam(Scoreboard.java:229)") {
+                            filterConsole("NullPointerException at Scoreboard.removeTeam")
+                            return Filter.Result.DENY
+                        }
+                        if (first.toString() == "net.minecraft.scoreboard.Scoreboard.createTeam(Scoreboard.java:218)") {
+                            filterConsole("IllegalArgumentException at Scoreboard.createTeam")
+                            return Filter.Result.DENY
+                        }
+                        if (first.toString() == "net.minecraft.scoreboard.Scoreboard.removeObjective(Scoreboard.java:179)") {
+                            filterConsole("IllegalArgumentException at Scoreboard.removeObjective")
+                            return Filter.Result.DENY
+                        }
+                    }
+                }
+            }
+            if (filterScoreboardErrors) {
+                if (thrown.toString() == "java.util.concurrent.ExecutionException: java.lang.IllegalArgumentException: A team with the name '") {
+                    filterConsole("IllegalArgumentException because scoreboard team already exists")
+                    return Filter.Result.DENY
+                }
+            }
+        }
+
+        if (!printUnfilteredDebugs) return Filter.Result.ACCEPT
+        if (!printUnfilteredDebugsOutsideSkyBlock && !LorenzUtils.inSkyblock) return Filter.Result.ACCEPT
+
+        println(" ")
+        println("filter 4/event ('$loggerConfigName'/'$loggerName')")
+        println("formattedMessage: '$formattedMessage'")
+        val threadName = event.threadName
+        println("threadName: '$threadName'")
+        val level = event.level
+        println("level: '$level'")
+        val marker = event.marker
+        if (marker != null) {
+            val name = marker.name
+            println("marker name: '$name'")
+        } else {
+            println("marker is null")
+        }
+        println("thrown: '$thrown'")
+        if (thrown != null) {
+            if (thrown.stackTrace.isNotEmpty()) {
+                var element = thrown.stackTrace[0]
+                println("thrown first element: '$element'")
+                val cause = thrown.cause
+                if (cause != null) {
+                    println("throw cause: '$cause'")
+                    element = cause.stackTrace[0]
+                    println("thrown cause first element: '$element'")
+                }
+            }
+        }
+        println(" ")
+
+        return Filter.Result.ACCEPT
+    }
+
+    private fun filterConsole(message: String) {
+        lorenzLogger.log(message)
+        if (printFilteredReason) {
+            LorenzUtils.consoleLog("filtered console: $message")
+        }
+    }
+
+    override fun getOnMismatch(): Filter.Result {
+        println("getOnMismatch ($loggerConfigName)")
+        return Filter.Result.DENY
+    }
+
+    override fun getOnMatch(): Filter.Result {
+        println("getOnMatch ($loggerConfigName)")
+        return Filter.Result.ACCEPT
+    }
+
+    override fun filter(
+        logger: Logger?,
+        level: Level?,
+        marker: Marker?,
+        msg: String?,
+        vararg params: Any?,
+    ): Filter.Result {
+        println("filter 1 ($loggerConfigName)")
+        return Filter.Result.ACCEPT
+    }
+
+    override fun filter(
+        logger: Logger?,
+        level: Level?,
+        marker: Marker?,
+        msg: Any?,
+        t: Throwable?,
+    ): Filter.Result {
+        println("filter 2 ($loggerConfigName)")
+        return Filter.Result.ACCEPT
+    }
+
+    override fun filter(
+        logger: Logger?,
+        level: Level?,
+        marker: Marker?,
+        msg: Message?,
+        t: Throwable?,
+    ): Filter.Result {
+        println("filter 3 ($loggerConfigName)")
+        return Filter.Result.ACCEPT
+    }
+}