Merge pull request #219 from sladkoff/refactor/tps

refactor(tick durations): composition and strategies

Author: sladkoff

.gitignore

@@ -4,4 +4,5 @@
 .settings
 .classpath
 .project
-.vscode
+.vscode
+/docker/data

docker-compose.yml

@@ -2,7 +2,7 @@ version: "3.8"
 
 services:
   mc:
-    image: itzg/minecraft-server:2024.2.0
+    image: itzg/minecraft-server:2024.1.0
     environment:
       EULA: "true"
       TYPE: "PAPER"
@@ -14,9 +14,7 @@ services:
       - "25565:25565"
       - "9225:9225"
     volumes:
-      - data:/data
+      - ./docker/data:/data
     stdin_open: true
     tty: true
     restart: unless-stopped
-volumes:
-  data: {}

src/main/java/de/sldk/mc/config/PrometheusExporterConfig.java

@@ -3,6 +3,10 @@
 import de.sldk.mc.MetricRegistry;
 import de.sldk.mc.PrometheusExporter;
 import de.sldk.mc.metrics.*;
+import de.sldk.mc.metrics.TickDurationAverageCollector;
+import de.sldk.mc.metrics.TickDurationMaxCollector;
+import de.sldk.mc.metrics.TickDurationMedianCollector;
+import de.sldk.mc.metrics.TickDurationMinCollector;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.plugin.Plugin;
 

src/main/java/de/sldk/mc/metrics/TickDurationAverageCollector.java

@@ -1,24 +1,25 @@
 package de.sldk.mc.metrics;
 
-import org.bukkit.plugin.Plugin;
-
+import de.sldk.mc.metrics.tick_duration.TickDurationCollector;
 import io.prometheus.client.Gauge;
+import org.bukkit.plugin.Plugin;
 
-public class TickDurationAverageCollector extends TickDurationCollector {
+public class TickDurationAverageCollector extends Metric {
     private static final String NAME = "tick_duration_average";
+    private final TickDurationCollector collector = TickDurationCollector.forServerImplementation(this.getPlugin());
 
     private static final Gauge TD = Gauge.build()
-            .name(prefix(NAME))
+            .name(Metric.prefix(NAME))
             .help("Average duration of server tick (nanoseconds)")
             .create();
 
     public TickDurationAverageCollector(Plugin plugin) {
-        super(plugin, TD, NAME);
+        super(plugin, TD);
     }
 
     private long getTickDurationAverage() {
         long sum = 0;
-        long[] durations = getTickDurations();
+        long[] durations = collector.getTickDurations();
         for (Long val : durations) {
             sum += val;
         }

src/main/java/de/sldk/mc/metrics/TickDurationMaxCollector.java

@@ -1,24 +1,25 @@
 package de.sldk.mc.metrics;
 
-import org.bukkit.plugin.Plugin;
-
+import de.sldk.mc.metrics.tick_duration.TickDurationCollector;
 import io.prometheus.client.Gauge;
+import org.bukkit.plugin.Plugin;
 
-public class TickDurationMaxCollector extends TickDurationCollector {
+public class TickDurationMaxCollector extends Metric {
     private static final String NAME = "tick_duration_max";
+    private final TickDurationCollector collector = TickDurationCollector.forServerImplementation(this.getPlugin());
 
     private static final Gauge TD = Gauge.build()
             .name(prefix(NAME))
             .help("Max duration of server tick (nanoseconds)")
             .create();
 
     public TickDurationMaxCollector(Plugin plugin) {
-        super(plugin, TD, NAME);
+        super(plugin, TD);
     }
 
     private long getTickDurationMax() {
         long max = Long.MIN_VALUE;
-        for (Long val : getTickDurations()) {
+        for (Long val : collector.getTickDurations()) {
             if (val > max) {
                 max = val;
             }

src/main/java/de/sldk/mc/metrics/TickDurationMedianCollector.java

@@ -1,26 +1,26 @@
 package de.sldk.mc.metrics;
 
-import java.util.Arrays;
-
+import de.sldk.mc.metrics.tick_duration.TickDurationCollector;
+import io.prometheus.client.Gauge;
 import org.bukkit.plugin.Plugin;
 
-import io.prometheus.client.Gauge;
+import java.util.Arrays;
 
-public class TickDurationMedianCollector extends TickDurationCollector {
+public class TickDurationMedianCollector extends Metric {
     private static final String NAME = "tick_duration_median";
+    private final TickDurationCollector collector = TickDurationCollector.forServerImplementation(this.getPlugin());
 
     private static final Gauge TD = Gauge.build()
             .name(prefix(NAME))
             .help("Median duration of server tick (nanoseconds)")
             .create();
 
     public TickDurationMedianCollector(Plugin plugin) {
-        super(plugin, TD, NAME);
+        super(plugin, TD);
     }
 
     private long getTickDurationMedian() {
-        /* Copy the original array - don't want to sort it! */
-        long[] tickTimes = getTickDurations().clone();
+        long[] tickTimes = collector.getTickDurations();
         Arrays.sort(tickTimes);
         return tickTimes[tickTimes.length / 2];
     }

src/main/java/de/sldk/mc/metrics/TickDurationMinCollector.java

@@ -1,24 +1,25 @@
 package de.sldk.mc.metrics;
 
-import org.bukkit.plugin.Plugin;
-
+import de.sldk.mc.metrics.tick_duration.TickDurationCollector;
 import io.prometheus.client.Gauge;
+import org.bukkit.plugin.Plugin;
 
-public class TickDurationMinCollector extends TickDurationCollector {
+public class TickDurationMinCollector extends Metric {
     private static final String NAME = "tick_duration_min";
+    private final TickDurationCollector collector = TickDurationCollector.forServerImplementation(this.getPlugin());
 
     private static final Gauge TD = Gauge.build()
             .name(prefix(NAME))
             .help("Min duration of server tick (nanoseconds)")
             .create();
 
     public TickDurationMinCollector(Plugin plugin) {
-        super(plugin, TD, NAME);
+        super(plugin, TD);
     }
 
     private long getTickDurationMin() {
         long min = Long.MAX_VALUE;
-        for (Long val : getTickDurations()) {
+        for (Long val : collector.getTickDurations()) {
             if (val < min) {
                 min = val;
             }

src/main/java/de/sldk/mc/metrics/TickDurationCollector.java src/main/java/de/sldk/mc/metrics/tick_duration/DefaultTickDurationStrategy.java

@@ -1,48 +1,31 @@
-package de.sldk.mc.metrics;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.logging.Level;
+package de.sldk.mc.metrics.tick_duration;
 
 import org.bukkit.Bukkit;
 import org.bukkit.Server;
-import org.bukkit.plugin.Plugin;
 
-import io.prometheus.client.Gauge;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
-public abstract class TickDurationCollector extends Metric {
+public class DefaultTickDurationStrategy implements TickDurationStrategy {
     /*
      * If reflection is successful, this will hold a reference directly to the
      * MinecraftServer internal tick duration tracker
      */
     private static long[] tickDurationReference = null;
 
-    /*
-     * If this server is Paper and has a shorthand method
-     * this will be set to true to use the method instead
-     */
-    private static boolean usePaperMethod = false;
-
-    public TickDurationCollector(Plugin plugin, Gauge gauge, String name) {
-        super(plugin, gauge);
-
+    public DefaultTickDurationStrategy(Logger logger) {
         /*
          * If there is not yet a handle to the internal tick duration buffer, try
          * to acquire one using reflection.
          *
          * This searches for any long[] array in the MinecraftServer class. It should
          * work across many versions of Spigot/Paper and various obfuscation mappings
          */
-        if (tickDurationReference == null && !usePaperMethod) {
-
-            /* Check if this server is Paper and has a handy method */
-            if (getPaperTickTimes() != null) {
-                usePaperMethod = true;
-                plugin.getLogger().log(Level.FINE, "Managed to get Paper tick times method.");
-                return;
-            }
+        if (tickDurationReference == null) {
 
-            plugin.getLogger().log(Level.FINE, "Could not get Paper tick times method.");
+            logger.log(Level.FINE, "Could not get Paper tick times method.");
 
             long[] longestArray = null;
 
@@ -63,7 +46,7 @@ public TickDurationCollector(Plugin plugin, Gauge gauge, String name) {
                     }
                 }
             } catch (Exception e) {
-                plugin.getLogger().log(Level.FINE, "Caught exception looking for tick times array: ", e);
+                logger.log(Level.FINE, "Caught exception looking for tick times array: ", e);
             }
 
             if (longestArray != null) {
@@ -73,47 +56,18 @@ public TickDurationCollector(Plugin plugin, Gauge gauge, String name) {
                 tickDurationReference = new long[1];
                 tickDurationReference[0] = -1;
 
-                plugin.getLogger().log(Level.WARNING, "Failed to find tick times buffer via reflection. Tick duration metrics will not be available.");
+                logger.log(Level.WARNING, "Failed to find tick times buffer via reflection. Tick duration metrics will not be available.");
             }
         }
     }
 
-    /**
-     * Attempts to get tick times from Paper
-     * returns null if fails
-     */
-    private static long[] getPaperTickTimes() {
-        try {
-            /* Get the actual minecraft server class */
-            Server server = Bukkit.getServer();
-
-            /* Attempt to get Paper tick times method */
-            Method paperGetTickTimesMethod = server.getClass().getMethod("getTickTimes");
-
-            Object tickTimes = paperGetTickTimesMethod.invoke(server);
-
-            /* Check the method actual return type */
-            if (!(tickTimes instanceof long[])) {
-                return null;
-            }
-
-            return (long[]) tickTimes;
-        }
-        catch (Exception e) {
-            return null;
-        }
-    }
-
     /**
      * Returns either the internal minecraft long array for tick times in ns,
      * or a long array containing just one element of value -1 if reflection
      * was unable to locate the minecraft tick times buffer
      */
-    protected static long[] getTickDurations() {
-        if (usePaperMethod) {
-            return getPaperTickTimes();
-        }
-
-        return tickDurationReference;
+    public long[] getTickDurations() {
+        // Return a copy of the array to prevent modification
+        return tickDurationReference.clone();
     }
 }

src/main/java/de/sldk/mc/metrics/tick_duration/PaperTickDurationStrategy.java

@@ -0,0 +1,41 @@
+package de.sldk.mc.metrics.tick_duration;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Server;
+
+import java.lang.reflect.Method;
+
+public class PaperTickDurationStrategy implements TickDurationStrategy {
+
+    public PaperTickDurationStrategy() {
+    }
+
+    /**
+     * Attempts to get tick times from Paper
+     * returns null if fails
+     */
+    private static long[] getPaperTickTimes() {
+        try {
+            /* Get the actual minecraft server class */
+            Server server = Bukkit.getServer();
+
+            /* Attempt to get Paper tick times method */
+            Method paperGetTickTimesMethod = server.getClass().getMethod("getTickTimes");
+
+            Object tickTimes = paperGetTickTimesMethod.invoke(server);
+
+            /* Check the method actual return type */
+            if (!(tickTimes instanceof long[])) {
+                return null;
+            }
+
+            return (long[]) tickTimes;
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    public long[] getTickDurations() {
+        return getPaperTickTimes();
+    }
+}

src/main/java/de/sldk/mc/metrics/tick_duration/TickDurationCollector.java

@@ -0,0 +1,33 @@
+package de.sldk.mc.metrics.tick_duration;
+
+import org.bukkit.plugin.Plugin;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class TickDurationCollector {
+
+    private final TickDurationStrategy strategy;
+
+    public TickDurationCollector(TickDurationStrategy strategy) {
+        this.strategy = strategy;
+    }
+
+    public static TickDurationCollector forServerImplementation(Plugin plugin) {
+        Logger logger = plugin.getLogger();
+        PaperTickDurationStrategy paperStrategy = new PaperTickDurationStrategy();
+
+        if (paperStrategy.getTickDurations() != null) {
+            logger.log(Level.FINE, "Using Paper tick times method.");
+            return new TickDurationCollector(paperStrategy);
+        }
+
+        logger.log(Level.FINE, "Using default tick times guessing method.");
+        DefaultTickDurationStrategy defaultTickDurationStrategy = new DefaultTickDurationStrategy(logger);
+        return new TickDurationCollector(defaultTickDurationStrategy);
+    }
+
+    public long[] getTickDurations() {
+        return strategy.getTickDurations();
+    }
+}

src/main/java/de/sldk/mc/metrics/tick_duration/TickDurationStrategy.java

@@ -0,0 +1,5 @@
+package de.sldk.mc.metrics.tick_duration;
+
+public interface TickDurationStrategy {
+    long[] getTickDurations();
+}