include threads by default in spark

divinemc-server/src/main/java/org/bxteam/divinemc/entity/pathfinding/AsyncPathProcessor.java

@@ -1,11 +1,12 @@
 package org.bxteam.divinemc.entity.pathfinding;
 
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import ca.spottedleaf.moonrise.common.util.TickThread;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.world.level.pathfinder.Path;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.bxteam.divinemc.DivineConfig;
+import org.bxteam.divinemc.util.NamedAgnosticThreadFactory;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -19,7 +20,7 @@ import java.util.function.Consumer;
  */
 @SuppressWarnings("DuplicatedCode")
 public class AsyncPathProcessor {
-    private static final String THREAD_PREFIX = "DivineMC Async Pathfinding";
+    private static final String THREAD_PREFIX = "Async Pathfinding";
     private static final Logger LOGGER = LogManager.getLogger(THREAD_PREFIX);
 
     private static long lastWarnMillis = System.currentTimeMillis();
@@ -28,10 +29,7 @@ public class AsyncPathProcessor {
         DivineConfig.asyncPathfindingMaxThreads,
         DivineConfig.asyncPathfindingKeepalive, TimeUnit.SECONDS,
         getQueueImpl(),
-        new ThreadFactoryBuilder()
-            .setNameFormat(THREAD_PREFIX + " Thread - %d")
-            .setPriority(Thread.NORM_PRIORITY - 2)
-            .build(),
+        new NamedAgnosticThreadFactory<>(THREAD_PREFIX, TickThread::new, Thread.NORM_PRIORITY - 2),
         new RejectedTaskHandler()
     );
 

divinemc-server/src/main/java/org/bxteam/divinemc/entity/tracking/MultithreadedTracker.java

@@ -2,10 +2,10 @@ package org.bxteam.divinemc.entity.tracking;
 
 import ca.spottedleaf.moonrise.common.list.ReferenceList;
 import ca.spottedleaf.moonrise.common.misc.NearbyPlayers;
+import ca.spottedleaf.moonrise.common.util.TickThread;
 import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
 import ca.spottedleaf.moonrise.patches.chunk_system.level.entity.server.ServerEntityLookup;
 import ca.spottedleaf.moonrise.patches.entity_tracker.EntityTrackerEntity;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import net.minecraft.server.level.ChunkMap;
 import net.minecraft.server.level.FullChunkStatus;
 import net.minecraft.server.level.ServerLevel;
@@ -13,6 +13,7 @@ import net.minecraft.world.entity.Entity;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.bxteam.divinemc.DivineConfig;
+import org.bxteam.divinemc.util.NamedAgnosticThreadFactory;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
@@ -26,7 +27,7 @@ import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 
 public class MultithreadedTracker {
-    private static final String THREAD_PREFIX = "DivineMC Async Tracker";
+    private static final String THREAD_PREFIX = "Async Tracker";
     private static final Logger LOGGER = LogManager.getLogger(THREAD_PREFIX);
 
     private static long lastWarnMillis = System.currentTimeMillis();
@@ -148,11 +149,7 @@ public class MultithreadedTracker {
     }
 
     private static @NotNull ThreadFactory getThreadFactory() {
-        return new ThreadFactoryBuilder()
-            .setThreadFactory(MultithreadedTrackerThread::new)
-            .setNameFormat(THREAD_PREFIX + " Thread - %d")
-            .setPriority(Thread.NORM_PRIORITY - 2)
-            .build();
+        return new NamedAgnosticThreadFactory<>(THREAD_PREFIX, TickThread::new, Thread.NORM_PRIORITY - 2);
     }
 
     private static @NotNull RejectedExecutionHandler getRejectedPolicy() {

divinemc-server/src/main/java/org/bxteam/divinemc/server/ServerLevelTickExecutorThreadFactory.java

@@ -1,6 +1,7 @@
 package org.bxteam.divinemc.server;
 
 import ca.spottedleaf.moonrise.common.util.TickThread;
+import org.bxteam.divinemc.spark.ThreadDumperRegistry;
 import java.util.concurrent.ThreadFactory;
 
 public class ServerLevelTickExecutorThreadFactory implements ThreadFactory {
@@ -8,6 +9,7 @@ public class ServerLevelTickExecutorThreadFactory implements ThreadFactory {
 
     public ServerLevelTickExecutorThreadFactory(String worldName) {
         this.worldName = worldName;
+        ThreadDumperRegistry.REGISTRY.add("serverlevel-tick-worker [" + worldName + "]");
     }
 
     @Override

divinemc-server/src/main/java/org/bxteam/divinemc/spark/DivineSparkPlugin.java

@@ -1,27 +1,176 @@
 package org.bxteam.divinemc.spark;
 
-import me.lucko.spark.paper.PaperSparkPlugin;
+import me.lucko.spark.paper.PaperClassSourceLookup;
+import me.lucko.spark.paper.PaperCommandSender;
+import me.lucko.spark.paper.PaperPlatformInfo;
+import me.lucko.spark.paper.PaperPlayerPingProvider;
+import me.lucko.spark.paper.PaperTickHook;
+import me.lucko.spark.paper.PaperTickReporter;
+import me.lucko.spark.paper.PaperWorldInfoProvider;
 import me.lucko.spark.paper.api.Compatibility;
 import me.lucko.spark.paper.api.PaperClassLookup;
 import me.lucko.spark.paper.api.PaperScheduler;
+import me.lucko.spark.paper.api.PaperSparkModule;
+import me.lucko.spark.paper.common.SparkPlatform;
+import me.lucko.spark.paper.common.SparkPlugin;
+import me.lucko.spark.paper.common.monitor.ping.PlayerPingProvider;
+import me.lucko.spark.paper.common.platform.PlatformInfo;
 import me.lucko.spark.paper.common.platform.serverconfig.ServerConfigProvider;
+import me.lucko.spark.paper.common.platform.world.WorldInfoProvider;
+import me.lucko.spark.paper.common.sampler.ThreadDumper;
+import me.lucko.spark.paper.common.sampler.source.ClassSourceLookup;
+import me.lucko.spark.paper.common.sampler.source.SourceMetadata;
+import me.lucko.spark.paper.common.tick.TickHook;
+import me.lucko.spark.paper.common.tick.TickReporter;
+import me.lucko.spark.paper.common.util.classfinder.ClassFinder;
 import org.bukkit.Server;
+import org.bukkit.command.CommandSender;
+import org.bukkit.plugin.Plugin;
 import org.jetbrains.annotations.NotNull;
 
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.stream.Stream;
 
-public class DivineSparkPlugin extends PaperSparkPlugin {
-    @NotNull
-    public static DivineSparkPlugin create(Compatibility ignoredCompatibility, Server server, Logger logger, PaperScheduler scheduler, PaperClassLookup classLookup) {
+public class DivineSparkPlugin implements PaperSparkModule, SparkPlugin {
+    private final Server server;
+    private final Logger logger;
+    private final PaperScheduler scheduler;
+    private final PaperClassLookup classLookup;
+    private final PaperTickHook tickHook;
+    private final PaperTickReporter tickReporter;
+    private final ThreadDumper gameThreadDumper;
+    private final SparkPlatform platform;
+
+    public DivineSparkPlugin(Server server, Logger logger, PaperScheduler scheduler, PaperClassLookup classLookup) {
+        this.server = server;
+        this.logger = logger;
+        this.scheduler = scheduler;
+        this.classLookup = classLookup;
+        this.tickHook = new PaperTickHook();
+        this.tickReporter = new PaperTickReporter();
+        this.gameThreadDumper = new ThreadDumperRegistry();
+        this.platform = new SparkPlatform(this);
+    }
+
+    public static @NotNull PaperSparkModule create(Compatibility compatibility, Server server, Logger logger, PaperScheduler scheduler, PaperClassLookup classLookup) {
         return new DivineSparkPlugin(server, logger, scheduler, classLookup);
     }
 
-    public DivineSparkPlugin(Server server, Logger logger, PaperScheduler scheduler, PaperClassLookup classLookup) {
-        super(server, logger, scheduler, classLookup);
+    public void enable() {
+        this.platform.enable();
+    }
+
+    public void disable() {
+        this.platform.disable();
+    }
+
+    public void executeCommand(CommandSender sender, String[] args) {
+        this.platform.executeCommand(new PaperCommandSender(sender), args);
+    }
+
+    public List<String> tabComplete(CommandSender sender, String[] args) {
+        return this.platform.tabCompleteCommand(new PaperCommandSender(sender), args);
+    }
+
+    public boolean hasPermission(CommandSender sender) {
+        return this.platform.hasPermissionForAnyCommand(new PaperCommandSender(sender));
+    }
+
+    public Collection<String> getPermissions() {
+        return this.platform.getAllSparkPermissions();
+    }
+
+    public void onServerTickStart() {
+        this.tickHook.onTick();
+    }
+
+    public void onServerTickEnd(double duration) {
+        this.tickReporter.onTick(duration);
+    }
+
+    public String getVersion() {
+        return "1.10.119";
+    }
+
+    public Path getPluginDirectory() {
+        return this.server.getPluginsFolder().toPath().resolve("spark");
+    }
+
+    public String getCommandName() {
+        return "spark";
+    }
+
+    public Stream<PaperCommandSender> getCommandSenders() {
+        return Stream.concat(this.server.getOnlinePlayers().stream(), Stream.of(this.server.getConsoleSender()))
+            .map((x$0) -> new PaperCommandSender(x$0));
+    }
+
+    public void executeAsync(Runnable task) {
+        this.scheduler.executeAsync(task);
+    }
+
+    public void executeSync(Runnable task) {
+        this.scheduler.executeSync(task);
+    }
+
+    public void log(Level level, String msg) {
+        this.logger.log(level, msg);
+    }
+
+    public void log(Level level, String msg, Throwable throwable) {
+        this.logger.log(level, msg, throwable);
+    }
+
+    public ThreadDumper getDefaultThreadDumper() {
+        return this.gameThreadDumper;
+    }
+
+    public TickHook createTickHook() {
+        return this.tickHook;
+    }
+
+    public TickReporter createTickReporter() {
+        return this.tickReporter;
+    }
+
+    public ClassSourceLookup createClassSourceLookup() {
+        return new PaperClassSourceLookup();
+    }
+
+    public ClassFinder createClassFinder() {
+        return (className) -> {
+            try {
+                return this.classLookup.lookup(className);
+            } catch (Exception var3) {
+                return null;
+            }
+        };
+    }
+
+    public Collection<SourceMetadata> getKnownSources() {
+        return SourceMetadata.gather(Arrays.asList(this.server.getPluginManager().getPlugins()), Plugin::getName, (plugin) -> plugin.getPluginMeta()
+            .getVersion(), (plugin) -> String.join(", ", plugin.getPluginMeta()
+            .getAuthors()), (plugin) -> plugin.getPluginMeta().getDescription());
+    }
+
+    public PlayerPingProvider createPlayerPingProvider() {
+        return new PaperPlayerPingProvider(this.server);
     }
 
-    @Override
     public ServerConfigProvider createServerConfigProvider() {
         return new DivineServerConfigProvider();
     }
+
+    public WorldInfoProvider createWorldInfoProvider() {
+        return new PaperWorldInfoProvider(this.server);
+    }
+
+    public PlatformInfo getPlatformInfo() {
+        return PaperPlatformInfo.INSTANCE;
+    }
 }

divinemc-server/src/main/java/org/bxteam/divinemc/spark/ThreadDumperRegistry.java

@@ -0,0 +1,44 @@
+package org.bxteam.divinemc.spark;
+
+import me.lucko.spark.paper.common.sampler.ThreadDumper;
+import me.lucko.spark.paper.common.util.ThreadFinder;
+import me.lucko.spark.paper.proto.SparkSamplerProtos;
+
+import java.lang.management.ThreadInfo;
+import java.lang.management.ThreadMXBean;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public final class ThreadDumperRegistry implements ThreadDumper {
+    public static final ConcurrentLinkedQueue<String> REGISTRY = new ConcurrentLinkedQueue<>();
+    private static final int STACK_TRACE_DEPTH = 10;
+    private final ThreadFinder threadFinder = new ThreadFinder();
+
+    @Override
+    public ThreadInfo[] dumpThreads(final ThreadMXBean threadMXBean) {
+        return this.threadFinder.getThreads()
+            .filter(thread -> isThreadIncluded(thread.threadId(), thread.getName()))
+            .map(thread -> threadMXBean.getThreadInfo(thread.threadId(), STACK_TRACE_DEPTH))
+            .filter(Objects::nonNull)
+            .toArray(ThreadInfo[]::new);
+    }
+
+    @Override
+    public boolean isThreadIncluded(long threadId, String threadName) {
+        for (final String prefix : REGISTRY) {
+            if (threadName.startsWith(prefix)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public SparkSamplerProtos.SamplerMetadata.ThreadDumper getMetadata() {
+        return SparkSamplerProtos.SamplerMetadata.ThreadDumper.newBuilder()
+            .setType(SparkSamplerProtos.SamplerMetadata.ThreadDumper.Type.SPECIFIC)
+            .addAllPatterns(REGISTRY)
+            .build();
+    }
+}

divinemc-server/src/main/java/org/bxteam/divinemc/util/NamedAgnosticThreadFactory.java

@@ -3,6 +3,7 @@ package org.bxteam.divinemc.util;
 import com.mojang.logging.LogUtils;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicInteger;
+import org.bxteam.divinemc.spark.ThreadDumperRegistry;
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 
@@ -19,6 +20,7 @@ public class NamedAgnosticThreadFactory<T extends Thread> implements ThreadFacto
         this.priority = priority;
         this.group = Thread.currentThread().getThreadGroup();
         this.namePrefix = name + "-";
+        ThreadDumperRegistry.REGISTRY.add(namePrefix);
     }
 
     @Override