Monitor average tick durations & report them in /spark tps

15 files changed, 369 insertions, 121 deletions

diff --git a/spark-common/src/main/java/me/lucko/spark/common/SparkPlatform.java b/spark-common/src/main/java/me/lucko/spark/common/SparkPlatform.java
index dc88306..340fa34 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/SparkPlatform.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/SparkPlatform.java
@@ -35,8 +35,9 @@ import me.lucko.spark.common.command.sender.CommandSender;
 import me.lucko.spark.common.command.tabcomplete.CompletionSupplier;
 import me.lucko.spark.common.command.tabcomplete.TabCompleter;
 import me.lucko.spark.common.monitor.cpu.CpuMonitor;
-import me.lucko.spark.common.monitor.tick.TpsCalculator;
-import me.lucko.spark.common.sampler.TickCounter;
+import me.lucko.spark.common.monitor.tick.TickStatistics;
+import me.lucko.spark.common.sampler.tick.TickHook;
+import me.lucko.spark.common.sampler.tick.TickReporter;
 import me.lucko.spark.common.util.BytebinClient;
 import net.kyori.text.TextComponent;
 import net.kyori.text.event.ClickEvent;
@@ -66,8 +67,9 @@ public class SparkPlatform {
     private final List<CommandModule> commandModules;
     private final List<Command> commands;
     private final ActivityLog activityLog;
-    private final TickCounter tickCounter;
-    private final TpsCalculator tpsCalculator;
+    private final TickHook tickHook;
+    private final TickReporter tickReporter;
+    private final TickStatistics tickStatistics;
 
     public SparkPlatform(SparkPlugin plugin) {
         this.plugin = plugin;
@@ -89,21 +91,29 @@ public class SparkPlatform {
         this.activityLog = new ActivityLog(plugin.getPluginDirectory().resolve("activity.json"));
         this.activityLog.load();
 
-        this.tickCounter = plugin.createTickCounter();
-        this.tpsCalculator = this.tickCounter != null ? new TpsCalculator() : null;
+        this.tickHook = plugin.createTickHook();
+        this.tickReporter = plugin.createTickReporter();
+        this.tickStatistics = this.tickHook != null ? new TickStatistics() : null;
     }
 
     public void enable() {
-        if (this.tickCounter != null) {
-            this.tickCounter.addTickTask(this.tpsCalculator);
-            this.tickCounter.start();
+        if (this.tickHook != null) {
+            this.tickHook.addCallback(this.tickStatistics);
+            this.tickHook.start();
+        }
+        if (this.tickReporter != null) {
+            this.tickReporter.addCallback(this.tickStatistics);
+            this.tickReporter.start();
         }
         CpuMonitor.ensureMonitoring();
     }
 
     public void disable() {
-        if (this.tickCounter != null) {
-            this.tickCounter.close();
+        if (this.tickHook != null) {
+            this.tickHook.close();
+        }
+        if (this.tickReporter != null) {
+            this.tickReporter.close();
         }
 
         for (CommandModule module : this.commandModules) {
@@ -119,12 +129,16 @@ public class SparkPlatform {
         return this.activityLog;
     }
 
-    public TickCounter getTickCounter() {
-        return this.tickCounter;
+    public TickHook getTickHook() {
+        return this.tickHook;
+    }
+
+    public TickReporter getTickReporter() {
+        return this.tickReporter;
     }
 
-    public TpsCalculator getTpsCalculator() {
-        return this.tpsCalculator;
+    public TickStatistics getTickStatistics() {
+        return this.tickStatistics;
     }
 
     public void executeCommand(CommandSender sender, String[] args) {
diff --git a/spark-common/src/main/java/me/lucko/spark/common/SparkPlugin.java b/spark-common/src/main/java/me/lucko/spark/common/SparkPlugin.java
index 1171b33..c0a928d 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/SparkPlugin.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/SparkPlugin.java
@@ -22,7 +22,8 @@ package me.lucko.spark.common;
 
 import me.lucko.spark.common.command.sender.CommandSender;
 import me.lucko.spark.common.sampler.ThreadDumper;
-import me.lucko.spark.common.sampler.TickCounter;
+import me.lucko.spark.common.sampler.tick.TickHook;
+import me.lucko.spark.common.sampler.tick.TickReporter;
 
 import java.nio.file.Path;
 import java.util.stream.Stream;
@@ -79,13 +80,24 @@ public interface SparkPlugin {
     }
 
     /**
-     * Creates a tick counter for the platform, if supported.
+     * Creates a tick hook for the platform, if supported.
      *
      * <p>Returns {@code null} if the platform does not have "ticks"</p>
      *
-     * @return a new tick counter
+     * @return a new tick hook
      */
-    default TickCounter createTickCounter() {
+    default TickHook createTickHook() {
+        return null;
+    }
+
+    /**
+     * Creates a tick reporter for the platform, if supported.
+     *
+     * <p>Returns {@code null} if the platform does not have "ticks"</p>
+     *
+     * @return a new tick reporter
+     */
+    default TickReporter createTickReporter() {
         return null;
     }
 
diff --git a/spark-common/src/main/java/me/lucko/spark/common/command/modules/HealthModule.java b/spark-common/src/main/java/me/lucko/spark/common/command/modules/HealthModule.java
index 0737a00..08233db 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/command/modules/HealthModule.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/command/modules/HealthModule.java
@@ -25,8 +25,9 @@ import me.lucko.spark.common.command.Command;
 import me.lucko.spark.common.command.CommandModule;
 import me.lucko.spark.common.command.tabcomplete.TabCompleter;
 import me.lucko.spark.common.monitor.cpu.CpuMonitor;
-import me.lucko.spark.common.monitor.tick.TpsCalculator;
+import me.lucko.spark.common.monitor.tick.TickStatistics;
 import me.lucko.spark.common.util.FormatUtil;
+import me.lucko.spark.common.util.RollingAverage;
 import net.kyori.text.Component;
 import net.kyori.text.TextComponent;
 import net.kyori.text.format.TextColor;
@@ -52,18 +53,29 @@ public class HealthModule implements CommandModule {
         consumer.accept(Command.builder()
                 .aliases("tps", "cpu")
                 .executor((platform, sender, resp, arguments) -> {
-                    TpsCalculator tpsCalculator = platform.getTpsCalculator();
-                    if (tpsCalculator != null) {
+                    TickStatistics tickStatistics = platform.getTickStatistics();
+                    if (tickStatistics != null) {
                         resp.replyPrefixed(TextComponent.of("TPS from last 5s, 10s, 1m, 5m, 15m:"));
                         resp.replyPrefixed(TextComponent.builder(" ")
-                                .append(formatTps(tpsCalculator.avg5Sec())).append(TextComponent.of(", "))
-                                .append(formatTps(tpsCalculator.avg10Sec())).append(TextComponent.of(", "))
-                                .append(formatTps(tpsCalculator.avg1Min())).append(TextComponent.of(", "))
-                                .append(formatTps(tpsCalculator.avg5Min())).append(TextComponent.of(", "))
-                                .append(formatTps(tpsCalculator.avg15Min()))
+                                .append(formatTps(tickStatistics.tps5Sec())).append(TextComponent.of(", "))
+                                .append(formatTps(tickStatistics.tps10Sec())).append(TextComponent.of(", "))
+                                .append(formatTps(tickStatistics.tps1Min())).append(TextComponent.of(", "))
+                                .append(formatTps(tickStatistics.tps5Min())).append(TextComponent.of(", "))
+                                .append(formatTps(tickStatistics.tps15Min()))
                                 .build()
                         );
                         resp.replyPrefixed(TextComponent.empty());
+
+                        if (tickStatistics.isDurationSupported()) {
+                            resp.replyPrefixed(TextComponent.of("Tick durations (avg/min/max ms) from last 5s, 10s, 1m:"));
+                            resp.replyPrefixed(TextComponent.builder(" ")
+                                    .append(formatTickDurations(tickStatistics.duration5Sec())).append(TextComponent.of(", "))
+                                    .append(formatTickDurations(tickStatistics.duration10Sec())).append(TextComponent.of(", "))
+                                    .append(formatTickDurations(tickStatistics.duration1Min()))
+                                    .build()
+                            );
+                            resp.replyPrefixed(TextComponent.empty());
+                        }
                     }
 
                     resp.replyPrefixed(TextComponent.of("CPU usage from last 10s, 1m, 15m:"));
@@ -95,8 +107,8 @@ public class HealthModule implements CommandModule {
                         List<Component> report = new LinkedList<>();
                         report.add(TextComponent.empty());
 
-                        TpsCalculator tpsCalculator = platform.getTpsCalculator();
-                        if (tpsCalculator != null) {
+                        TickStatistics tickStatistics = platform.getTickStatistics();
+                        if (tickStatistics != null) {
                             report.add(TextComponent.builder("")
                                     .append(TextComponent.builder(">").color(TextColor.DARK_GRAY).decoration(TextDecoration.BOLD, true).build())
                                     .append(TextComponent.space())
@@ -104,14 +116,30 @@ public class HealthModule implements CommandModule {
                                     .build()
                             );
                             report.add(TextComponent.builder("    ")
-                                    .append(formatTps(tpsCalculator.avg5Sec())).append(TextComponent.of(", "))
-                                    .append(formatTps(tpsCalculator.avg10Sec())).append(TextComponent.of(", "))
-                                    .append(formatTps(tpsCalculator.avg1Min())).append(TextComponent.of(", "))
-                                    .append(formatTps(tpsCalculator.avg5Min())).append(TextComponent.of(", "))
-                                    .append(formatTps(tpsCalculator.avg15Min()))
+                                    .append(formatTps(tickStatistics.tps5Sec())).append(TextComponent.of(", "))
+                                    .append(formatTps(tickStatistics.tps10Sec())).append(TextComponent.of(", "))
+                                    .append(formatTps(tickStatistics.tps1Min())).append(TextComponent.of(", "))
+                                    .append(formatTps(tickStatistics.tps5Min())).append(TextComponent.of(", "))
+                                    .append(formatTps(tickStatistics.tps15Min()))
                                     .build()
                             );
                             report.add(TextComponent.empty());
+
+                            if (tickStatistics.isDurationSupported()) {
+                                report.add(TextComponent.builder("")
+                                        .append(TextComponent.builder(">").color(TextColor.DARK_GRAY).decoration(TextDecoration.BOLD, true).build())
+                                        .append(TextComponent.space())
+                                        .append(TextComponent.of("Tick durations (avg/min/max ms) from last 5s, 10s, 1m:", TextColor.GOLD))
+                                        .build()
+                                );
+                                report.add(TextComponent.builder("    ")
+                                        .append(formatTickDurations(tickStatistics.duration5Sec())).append(TextComponent.of(", "))
+                                        .append(formatTickDurations(tickStatistics.duration10Sec())).append(TextComponent.of(", "))
+                                        .append(formatTickDurations(tickStatistics.duration1Min()))
+                                        .build()
+                                );
+                                report.add(TextComponent.empty());
+                            }
                         }
 
                         report.add(TextComponent.builder("")
@@ -269,6 +297,29 @@ public class HealthModule implements CommandModule {
         return TextComponent.of( (tps > 20.0 ? "*" : "") + Math.min(Math.round(tps * 100.0) / 100.0, 20.0), color);
     }
 
+    public static TextComponent formatTickDurations(RollingAverage average){
+        return TextComponent.builder("")
+                .append(formatTickDuration(average.getAverage()))
+                .append(TextComponent.of('/', TextColor.GRAY))
+                .append(formatTickDuration(average.getMin()))
+                .append(TextComponent.of('/', TextColor.GRAY))
+                .append(formatTickDuration(average.getMax()))
+                .build();
+    }
+
+    public static TextComponent formatTickDuration(double duration){
+        TextColor color;
+        if (duration >= 50d) {
+            color = TextColor.RED;
+        } else if (duration >= 40d) {
+            color = TextColor.YELLOW;
+        } else {
+            color = TextColor.GREEN;
+        }
+
+        return TextComponent.of(String.format("%.1f", duration), color);
+    }
+
     public static TextComponent formatCpuUsage(double usage) {
         TextColor color;
         if (usage > 0.9) {
diff --git a/spark-common/src/main/java/me/lucko/spark/common/command/modules/SamplerModule.java b/spark-common/src/main/java/me/lucko/spark/common/command/modules/SamplerModule.java
index cd98aa4..919931e 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/command/modules/SamplerModule.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/command/modules/SamplerModule.java
@@ -32,7 +32,7 @@ import me.lucko.spark.common.sampler.SamplerBuilder;
 import me.lucko.spark.common.sampler.ThreadDumper;
 import me.lucko.spark.common.sampler.ThreadGrouper;
 import me.lucko.spark.common.sampler.ThreadNodeOrder;
-import me.lucko.spark.common.sampler.TickCounter;
+import me.lucko.spark.common.sampler.tick.TickHook;
 import net.kyori.text.TextComponent;
 import net.kyori.text.event.ClickEvent;
 import net.kyori.text.format.TextColor;
@@ -167,10 +167,10 @@ public class SamplerModule implements CommandModule {
                     }
 
                     int ticksOver = arguments.intFlag("only-ticks-over");
-                    TickCounter tickCounter = null;
+                    TickHook tickHook = null;
                     if (ticksOver != -1) {
-                        tickCounter = platform.getTickCounter();
-                        if (tickCounter == null) {
+                        tickHook = platform.getTickHook();
+                        if (tickHook == null) {
                             resp.replyPrefixed(TextComponent.of("Tick counting is not supported!", TextColor.RED));
                             return;
                         }
@@ -193,7 +193,7 @@ public class SamplerModule implements CommandModule {
                     builder.includeLineNumbers(includeLineNumbers);
                     builder.ignoreSleeping(ignoreSleeping);
                     if (ticksOver != -1) {
-                        builder.ticksOver(ticksOver, tickCounter);
+                        builder.ticksOver(ticksOver, tickHook);
                     }
                     Sampler sampler = this.activeSampler = builder.start();
 
diff --git a/spark-common/src/main/java/me/lucko/spark/common/command/modules/TickMonitoringModule.java b/spark-common/src/main/java/me/lucko/spark/common/command/modules/TickMonitoringModule.java
index 0ebb252..245a55b 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/command/modules/TickMonitoringModule.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/command/modules/TickMonitoringModule.java
@@ -26,7 +26,7 @@ import me.lucko.spark.common.command.CommandModule;
 import me.lucko.spark.common.command.CommandResponseHandler;
 import me.lucko.spark.common.command.tabcomplete.TabCompleter;
 import me.lucko.spark.common.monitor.tick.TickMonitor;
-import me.lucko.spark.common.sampler.TickCounter;
+import me.lucko.spark.common.sampler.tick.TickHook;
 import net.kyori.text.Component;
 import net.kyori.text.TextComponent;
 import net.kyori.text.format.TextColor;
@@ -35,14 +35,14 @@ import java.util.function.Consumer;
 
 public class TickMonitoringModule implements CommandModule {
 
-    /** The tick monitor instance currently running, if any */
-    private TickCounter tickCounter = null;
+    /** The tick hook instance currently running, if any */
+    private TickHook tickHook = null;
     private ReportingTickMonitor activeTickMonitor = null;
 
     @Override
     public void close() {
         if (this.activeTickMonitor != null) {
-            this.tickCounter.removeTickTask(this.activeTickMonitor);
+            this.tickHook.removeCallback(this.activeTickMonitor);
             this.activeTickMonitor.close();
             this.activeTickMonitor = null;
         }
@@ -55,10 +55,10 @@ public class TickMonitoringModule implements CommandModule {
                 .argumentUsage("threshold", "percentage increase")
                 .argumentUsage("without-gc", null)
                 .executor((platform, sender, resp, arguments) -> {
-                    if (this.tickCounter == null) {
-                        this.tickCounter = platform.getTickCounter();
+                    if (this.tickHook == null) {
+                        this.tickHook = platform.getTickHook();
                     }
-                    if (this.tickCounter == null) {
+                    if (this.tickHook == null) {
                         resp.replyPrefixed(TextComponent.of("Not supported!", TextColor.RED));
                         return;
                     }
@@ -69,8 +69,8 @@ public class TickMonitoringModule implements CommandModule {
                             threshold = 100;
                         }
 
-                        this.activeTickMonitor = new ReportingTickMonitor(platform, resp, this.tickCounter, threshold, !arguments.boolFlag("without-gc"));
-                        this.tickCounter.addTickTask(this.activeTickMonitor);
+                        this.activeTickMonitor = new ReportingTickMonitor(platform, resp, this.tickHook, threshold, !arguments.boolFlag("without-gc"));
+                        this.tickHook.addCallback(this.activeTickMonitor);
                     } else {
                         close();
                         resp.broadcastPrefixed(TextComponent.of("Tick monitor disabled."));
@@ -84,8 +84,8 @@ public class TickMonitoringModule implements CommandModule {
     private static class ReportingTickMonitor extends TickMonitor {
         private final CommandResponseHandler resp;
 
-        ReportingTickMonitor(SparkPlatform platform, CommandResponseHandler resp, TickCounter tickCounter, int percentageChangeThreshold, boolean monitorGc) {
-            super(platform, tickCounter, percentageChangeThreshold, monitorGc);
+        ReportingTickMonitor(SparkPlatform platform, CommandResponseHandler resp, TickHook tickHook, int percentageChangeThreshold, boolean monitorGc) {
+            super(platform, tickHook, percentageChangeThreshold, monitorGc);
             this.resp = resp;
         }
 
diff --git a/spark-common/src/main/java/me/lucko/spark/common/monitor/tick/TickMonitor.java b/spark-common/src/main/java/me/lucko/spark/common/monitor/tick/TickMonitor.java
index fa4b83c..7015b4a 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/monitor/tick/TickMonitor.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/monitor/tick/TickMonitor.java
@@ -23,7 +23,7 @@ package me.lucko.spark.common.monitor.tick;
 import com.sun.management.GarbageCollectionNotificationInfo;
 import me.lucko.spark.common.SparkPlatform;
 import me.lucko.spark.common.monitor.memory.GarbageCollectionMonitor;
-import me.lucko.spark.common.sampler.TickCounter;
+import me.lucko.spark.common.sampler.tick.TickHook;
 import net.kyori.text.Component;
 import net.kyori.text.TextComponent;
 import net.kyori.text.format.TextColor;
@@ -31,11 +31,11 @@ import net.kyori.text.format.TextColor;
 import java.text.DecimalFormat;
 import java.util.DoubleSummaryStatistics;
 
-public abstract class TickMonitor implements TickCounter.TickTask, GarbageCollectionMonitor.Listener, AutoCloseable {
+public abstract class TickMonitor implements TickHook.Callback, GarbageCollectionMonitor.Listener, AutoCloseable {
     private static final DecimalFormat df = new DecimalFormat("#.##");
 
     private final SparkPlatform platform;
-    private final TickCounter tickCounter;
+    private final TickHook tickHook;
     private final int zeroTick;
     private final GarbageCollectionMonitor garbageCollectionMonitor;
     private final int percentageChangeThreshold;
@@ -46,10 +46,10 @@ public abstract class TickMonitor implements TickCounter.TickTask, GarbageCollec
     private final DoubleSummaryStatistics averageTickTime = new DoubleSummaryStatistics();
     private double avg;
 
-    public TickMonitor(SparkPlatform platform, TickCounter tickCounter, int percentageChangeThreshold, boolean monitorGc) {
+    public TickMonitor(SparkPlatform platform, TickHook tickHook, int percentageChangeThreshold, boolean monitorGc) {
         this.platform = platform;
-        this.tickCounter = tickCounter;
-        this.zeroTick = tickCounter.getCurrentTick();
+        this.tickHook = tickHook;
+        this.zeroTick = tickHook.getCurrentTick();
         this.percentageChangeThreshold = percentageChangeThreshold;
 
         if (monitorGc) {
@@ -61,7 +61,7 @@ public abstract class TickMonitor implements TickCounter.TickTask, GarbageCollec
     }
 
     public int getCurrentTick() {
-        return this.tickCounter.getCurrentTick() - this.zeroTick;
+        return this.tickHook.getCurrentTick() - this.zeroTick;
     }
 
     protected abstract void sendMessage(Component message);
@@ -74,7 +74,7 @@ public abstract class TickMonitor implements TickCounter.TickTask, GarbageCollec
     }
 
     @Override
-    public void onTick(TickCounter counter) {
+    public void onTick(TickHook hook) {
         double now = ((double) System.nanoTime()) / 1000000d;
 
         // init
diff --git a/spark-common/src/main/java/me/lucko/spark/common/monitor/tick/TpsCalculator.java b/spark-common/src/main/java/me/lucko/spark/common/monitor/tick/TickStatistics.java
index 6b4f2d1..c91ceae 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/monitor/tick/TpsCalculator.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/monitor/tick/TickStatistics.java
@@ -20,7 +20,9 @@
 
 package me.lucko.spark.common.monitor.tick;
 
-import me.lucko.spark.common.sampler.TickCounter;
+import me.lucko.spark.common.sampler.tick.TickHook;
+import me.lucko.spark.common.sampler.tick.TickReporter;
+import me.lucko.spark.common.util.RollingAverage;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
@@ -37,28 +39,35 @@ import java.util.concurrent.TimeUnit;
  * rather avoid that. Secondly, it allows us to generate rolling averages over a shorter period of
  * time.</p>
  */
-public class TpsCalculator implements TickCounter.TickTask {
+public class TickStatistics implements TickHook.Callback, TickReporter.Callback {
 
     private static final long SEC_IN_NANO = TimeUnit.SECONDS.toNanos(1);
     private static final int TPS = 20;
-    private static final int SAMPLE_INTERVAL = 20;
-    private static final BigDecimal TPS_BASE = new BigDecimal(SEC_IN_NANO).multiply(new BigDecimal(SAMPLE_INTERVAL));
-
-    private final TpsRollingAverage avg5Sec = new TpsRollingAverage(5);
-    private final TpsRollingAverage avg10Sec = new TpsRollingAverage(10);
-    private final TpsRollingAverage avg1Min = new TpsRollingAverage(60);
-    private final TpsRollingAverage avg5Min = new TpsRollingAverage(60 * 5);
-    private final TpsRollingAverage avg15Min = new TpsRollingAverage(60 * 15);
-
-    private final TpsRollingAverage[] averages = new TpsRollingAverage[]{
-            this.avg5Sec, this.avg10Sec, this.avg1Min, this.avg5Min, this.avg15Min
-    };
+    private static final int TPS_SAMPLE_INTERVAL = 20;
+    private static final BigDecimal TPS_BASE = new BigDecimal(SEC_IN_NANO).multiply(new BigDecimal(TPS_SAMPLE_INTERVAL));
+
+    private final TpsRollingAverage tps5Sec = new TpsRollingAverage(5);
+    private final TpsRollingAverage tps10Sec = new TpsRollingAverage(10);
+    private final TpsRollingAverage tps1Min = new TpsRollingAverage(60);
+    private final TpsRollingAverage tps5Min = new TpsRollingAverage(60 * 5);
+    private final TpsRollingAverage tps15Min = new TpsRollingAverage(60 * 15);
+    private final TpsRollingAverage[] tpsAverages = {this.tps5Sec, this.tps10Sec, this.tps1Min, this.tps5Min, this.tps15Min};
+
+    private boolean durationSupported = false;
+    private final RollingAverage tickDuration5Sec = new RollingAverage(TPS * 5);
+    private final RollingAverage tickDuration10Sec = new RollingAverage(TPS * 10);
+    private final RollingAverage tickDuration1Min = new RollingAverage(TPS * 60);
+    private final RollingAverage[] tickDurationAverages = {this.tickDuration5Sec, this.tickDuration10Sec, this.tickDuration1Min};
 
     private long last = 0;
 
+    public boolean isDurationSupported() {
+        return this.durationSupported;
+    }
+
     @Override
-    public void onTick(TickCounter counter) {
-        if (counter.getCurrentTick() % SAMPLE_INTERVAL != 0) {
+    public void onTick(TickHook hook) {
+        if (hook.getCurrentTick() % TPS_SAMPLE_INTERVAL != 0) {
             return;
         }
 
@@ -73,33 +82,62 @@ public class TpsCalculator implements TickCounter.TickTask {
         BigDecimal currentTps = TPS_BASE.divide(new BigDecimal(diff), 30, RoundingMode.HALF_UP);
         BigDecimal total = currentTps.multiply(new BigDecimal(diff));
 
-        for (TpsRollingAverage rollingAverage : this.averages) {
+        for (TpsRollingAverage rollingAverage : this.tpsAverages) {
             rollingAverage.add(currentTps, diff, total);
         }
 
         this.last = now;
     }
 
-    public double avg5Sec() {
-        return this.avg5Sec.getAverage();
+    @Override
+    public void onTick(double duration) {
+        this.durationSupported = true;
+        BigDecimal decimal = BigDecimal.valueOf(duration);
+        for (RollingAverage rollingAverage : this.tickDurationAverages) {
+            rollingAverage.add(decimal);
+        }
+    }
+
+    public double tps5Sec() {
+        return this.tps5Sec.getAverage();
     }
 
-    public double avg10Sec() {
-        return this.avg10Sec.getAverage();
+    public double tps10Sec() {
+        return this.tps10Sec.getAverage();
     }
 
-    public double avg1Min() {
-        return this.avg1Min.getAverage();
+    public double tps1Min() {
+        return this.tps1Min.getAverage();
     }
 
-    public double avg5Min() {
-        return this.avg5Min.getAverage();
+    public double tps5Min() {
+        return this.tps5Min.getAverage();
     }
 
-    public double avg15Min() {
-        return this.avg15Min.getAverage();
+    public double tps15Min() {
+        return this.tps15Min.getAverage();
     }
 
+    public RollingAverage duration5Sec() {
+        if (!this.durationSupported) {
+            return null;
+        }
+        return this.tickDuration5Sec;
+    }
+
+    public RollingAverage duration10Sec() {
+        if (!this.durationSupported) {
+            return null;
+        }
+        return this.tickDuration10Sec;
+    }
+
+    public RollingAverage duration1Min() {
+        if (!this.durationSupported) {
+            return null;
+        }
+        return this.tickDuration1Min;
+    }
 
 
     /**
diff --git a/spark-common/src/main/java/me/lucko/spark/common/sampler/Sampler.java b/spark-common/src/main/java/me/lucko/spark/common/sampler/Sampler.java
index 81a757a..56093c0 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/sampler/Sampler.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/sampler/Sampler.java
@@ -27,6 +27,7 @@ import me.lucko.spark.common.sampler.aggregator.DataAggregator;
 import me.lucko.spark.common.sampler.aggregator.SimpleDataAggregator;
 import me.lucko.spark.common.sampler.aggregator.TickedDataAggregator;
 import me.lucko.spark.common.sampler.node.ThreadNode;
+import me.lucko.spark.common.sampler.tick.TickHook;
 import me.lucko.spark.proto.SparkProtos.SamplerData;
 import me.lucko.spark.proto.SparkProtos.SamplerMetadata;
 
@@ -86,9 +87,9 @@ public class Sampler implements Runnable {
         this.endTime = endTime;
     }
 
-    public Sampler(int interval, ThreadDumper threadDumper, ThreadGrouper threadGrouper, long endTime, boolean includeLineNumbers, boolean ignoreSleeping, TickCounter tickCounter, int tickLengthThreshold) {
+    public Sampler(int interval, ThreadDumper threadDumper, ThreadGrouper threadGrouper, long endTime, boolean includeLineNumbers, boolean ignoreSleeping, TickHook tickHook, int tickLengthThreshold) {
         this.threadDumper = threadDumper;
-        this.dataAggregator = new TickedDataAggregator(this.workerPool, threadGrouper, interval, includeLineNumbers, ignoreSleeping, tickCounter, tickLengthThreshold);
+        this.dataAggregator = new TickedDataAggregator(this.workerPool, threadGrouper, interval, includeLineNumbers, ignoreSleeping, tickHook, tickLengthThreshold);
         this.interval = interval;
         this.endTime = endTime;
     }
diff --git a/spark-common/src/main/java/me/lucko/spark/common/sampler/SamplerBuilder.java b/spark-common/src/main/java/me/lucko/spark/common/sampler/SamplerBuilder.java
index 4808214..ae7fb89 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/sampler/SamplerBuilder.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/sampler/SamplerBuilder.java
@@ -20,6 +20,8 @@
 
 package me.lucko.spark.common.sampler;
 
+import me.lucko.spark.common.sampler.tick.TickHook;
+
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -35,7 +37,7 @@ public class SamplerBuilder {
     private ThreadGrouper threadGrouper = ThreadGrouper.BY_NAME;
 
     private int ticksOver = -1;
-    private TickCounter tickCounter = null;
+    private TickHook tickHook = null;
 
     public SamplerBuilder() {
     }
@@ -63,9 +65,9 @@ public class SamplerBuilder {
         return this;
     }
 
-    public SamplerBuilder ticksOver(int ticksOver, TickCounter tickCounter) {
+    public SamplerBuilder ticksOver(int ticksOver, TickHook tickHook) {
         this.ticksOver = ticksOver;
-        this.tickCounter = tickCounter;
+        this.tickHook = tickHook;
         return this;
     }
 
@@ -83,10 +85,10 @@ public class SamplerBuilder {
         Sampler sampler;
 
         int intervalMicros = (int) (this.samplingInterval * 1000d);
-        if (this.ticksOver == -1 || this.tickCounter == null) {
+        if (this.ticksOver == -1 || this.tickHook == null) {
             sampler = new Sampler(intervalMicros, this.threadDumper, this.threadGrouper, this.timeout, this.includeLineNumbers, this.ignoreSleeping);
         } else {
-            sampler = new Sampler(intervalMicros, this.threadDumper, this.threadGrouper, this.timeout, this.includeLineNumbers, this.ignoreSleeping, this.tickCounter, this.ticksOver);
+            sampler = new Sampler(intervalMicros, this.threadDumper, this.threadGrouper, this.timeout, this.includeLineNumbers, this.ignoreSleeping, this.tickHook, this.ticksOver);
         }
 
         sampler.start();
diff --git a/spark-common/src/main/java/me/lucko/spark/common/sampler/aggregator/TickedDataAggregator.java b/spark-common/src/main/java/me/lucko/spark/common/sampler/aggregator/TickedDataAggregator.java
index a4dfdb8..d8fda73 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/sampler/aggregator/TickedDataAggregator.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/sampler/aggregator/TickedDataAggregator.java
@@ -21,8 +21,8 @@
 package me.lucko.spark.common.sampler.aggregator;
 
 import me.lucko.spark.common.sampler.ThreadGrouper;
-import me.lucko.spark.common.sampler.TickCounter;
 import me.lucko.spark.common.sampler.node.ThreadNode;
+import me.lucko.spark.common.sampler.tick.TickHook;
 import me.lucko.spark.proto.SparkProtos.SamplerMetadata;
 
 import java.lang.management.ThreadInfo;
@@ -39,7 +39,7 @@ import java.util.concurrent.TimeUnit;
 public class TickedDataAggregator extends AbstractDataAggregator {
 
     /** Used to monitor the current "tick" of the server */
-    private final TickCounter tickCounter;
+    private final TickHook tickHook;
 
     /** Tick durations under this threshold will not be inserted, measured in microseconds */
     private final long tickLengthThreshold;
@@ -53,9 +53,9 @@ public class TickedDataAggregator extends AbstractDataAggregator {
     private int currentTick = -1;
     private TickList currentData = new TickList(0);
 
-    public TickedDataAggregator(ExecutorService workerPool, ThreadGrouper threadGrouper, int interval, boolean includeLineNumbers, boolean ignoreSleeping, TickCounter tickCounter, int tickLengthThreshold) {
+    public TickedDataAggregator(ExecutorService workerPool, ThreadGrouper threadGrouper, int interval, boolean includeLineNumbers, boolean ignoreSleeping, TickHook tickHook, int tickLengthThreshold) {
         super(workerPool, threadGrouper, interval, includeLineNumbers, ignoreSleeping);
-        this.tickCounter = tickCounter;
+        this.tickHook = tickHook;
         this.tickLengthThreshold = TimeUnit.MILLISECONDS.toMicros(tickLengthThreshold);
         // 50 millis in a tick, plus 10 so we have a bit of room to go over
         double intervalMilliseconds = interval / 1000d;
@@ -74,7 +74,7 @@ public class TickedDataAggregator extends AbstractDataAggregator {
     @Override
     public void insertData(ThreadInfo threadInfo) {
         synchronized (this.mutex) {
-            int tick = this.tickCounter.getCurrentTick();
+            int tick = this.tickHook.getCurrentTick();
             if (this.currentTick != tick) {
                 pushCurrentTick();
                 this.currentTick = tick;
diff --git a/spark-common/src/main/java/me/lucko/spark/common/sampler/AbstractTickCounter.java b/spark-common/src/main/java/me/lucko/spark/common/sampler/tick/AbstractTickHook.java
index 4633024..b4e5054 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/sampler/AbstractTickCounter.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/sampler/tick/AbstractTickHook.java
@@ -18,18 +18,18 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-package me.lucko.spark.common.sampler;
+package me.lucko.spark.common.sampler.tick;
 
 import java.util.HashSet;
 import java.util.Set;
 
-public abstract class AbstractTickCounter implements TickCounter {
+public abstract class AbstractTickHook implements TickHook {
 
-    private final Set<TickTask> tasks = new HashSet<>();
+    private final Set<Callback> tasks = new HashSet<>();
     private int tick = 0;
 
     protected void onTick() {
-        for (TickTask r : this.tasks) {
+        for (Callback r : this.tasks) {
             r.onTick(this);
         }
         this.tick++;
@@ -41,12 +41,12 @@ public abstract class AbstractTickCounter implements TickCounter {
     }
 
     @Override
-    public void addTickTask(TickTask runnable) {
+    public void addCallback(Callback runnable) {
         this.tasks.add(runnable);
     }
 
     @Override
-    public void removeTickTask(TickTask runnable) {
+    public void removeCallback(Callback runnable) {
         this.tasks.remove(runnable);
     }
 
diff --git a/spark-common/src/main/java/me/lucko/spark/common/sampler/tick/AbstractTickReporter.java b/spark-common/src/main/java/me/lucko/spark/common/sampler/tick/AbstractTickReporter.java
new file mode 100644
index 0000000..4005f87
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/sampler/tick/AbstractTickReporter.java
@@ -0,0 +1,45 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.sampler.tick;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public abstract class AbstractTickReporter implements TickReporter {
+    private final Set<Callback> tasks = new HashSet<>();
+
+    protected void onTick(double duration) {
+        for (Callback r : this.tasks) {
+            r.onTick(duration);
+        }
+    }
+
+    @Override
+    public void addCallback(Callback runnable) {
+        this.tasks.add(runnable);
+    }
+
+    @Override
+    public void removeCallback(Callback runnable) {
+        this.tasks.remove(runnable);
+    }
+
+}
diff --git a/spark-common/src/main/java/me/lucko/spark/common/sampler/TickCounter.java b/spark-common/src/main/java/me/lucko/spark/common/sampler/tick/TickHook.java
index aa839ba..a0dd425 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/sampler/TickCounter.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/sampler/tick/TickHook.java
@@ -18,20 +18,20 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-package me.lucko.spark.common.sampler;
+package me.lucko.spark.common.sampler.tick;
 
 /**
  * A hook with the game's "tick loop".
  */
-public interface TickCounter extends AutoCloseable {
+public interface TickHook extends AutoCloseable {
 
     /**
-     * Starts the counter
+     * Starts the hook
      */
     void start();
 
     /**
-     * Stops the counter
+     * Stops the hook
      */
     @Override
     void close();
@@ -44,21 +44,21 @@ public interface TickCounter extends AutoCloseable {
     int getCurrentTick();
 
     /**
-     * Adds a task to be called each time the tick increments
+     * Adds a callback to be called each time the tick increments
      *
      * @param runnable the task
      */
-    void addTickTask(TickTask runnable);
+    void addCallback(Callback runnable);
 
     /**
-     * Removes a tick task
+     * Removes a callback
      *
-     * @param runnable the task
+     * @param runnable the callback
      */
-    void removeTickTask(TickTask runnable);
+    void removeCallback(Callback runnable);
 
-    interface TickTask {
-        void onTick(TickCounter counter);
+    interface Callback {
+        void onTick(TickHook hook);
     }
 
 }
diff --git a/spark-common/src/main/java/me/lucko/spark/common/sampler/tick/TickReporter.java b/spark-common/src/main/java/me/lucko/spark/common/sampler/tick/TickReporter.java
new file mode 100644
index 0000000..e922e72
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/sampler/tick/TickReporter.java
@@ -0,0 +1,57 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.common.sampler.tick;
+
+/**
+ * A reporting callback for the game's "tick loop".
+ */
+public interface TickReporter extends AutoCloseable {
+
+    /**
+     * Starts the reporter
+     */
+    void start();
+
+    /**
+     * Stops the reporter
+     */
+    @Override
+    void close();
+
+    /**
+     * Adds a callback to be called each time the tick increments
+     *
+     * @param runnable the callback
+     */
+    void addCallback(Callback runnable);
+
+    /**
+     * Removes a callback
+     *
+     * @param runnable callback
+     */
+    void removeCallback(Callback runnable);
+
+    interface Callback {
+        void onTick(double duration);
+    }
+
+}
diff --git a/spark-common/src/main/java/me/lucko/spark/common/util/RollingAverage.java b/spark-common/src/main/java/me/lucko/spark/common/util/RollingAverage.java
index 514876d..5cf5bb5 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/util/RollingAverage.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/util/RollingAverage.java
@@ -37,18 +37,46 @@ public class RollingAverage {
     }
 
     public void add(BigDecimal num) {
-        this.total = this.total.add(num);
-        this.samples.add(num);
-        if (this.samples.size() > this.size) {
-            this.total = this.total.subtract(this.samples.remove());
+        synchronized (this) {
+            this.total = this.total.add(num);
+            this.samples.add(num);
+            if (this.samples.size() > this.size) {
+                this.total = this.total.subtract(this.samples.remove());
+            }
         }
     }
 
     public double getAverage() {
-        if (this.samples.isEmpty()) {
-            return 0;
+        synchronized (this) {
+            if (this.samples.isEmpty()) {
+                return 0;
+            }
+            return this.total.divide(BigDecimal.valueOf(this.samples.size()), 30, RoundingMode.HALF_UP).doubleValue();
+        }
+    }
+
+    public double getMax() {
+        synchronized (this) {
+            BigDecimal max = BigDecimal.ZERO;
+            for (BigDecimal sample : this.samples) {
+                if (sample.compareTo(max) > 0) {
+                    max = sample;
+                }
+            }
+            return max.doubleValue();
+        }
+    }
+
+    public double getMin() {
+        synchronized (this) {
+            BigDecimal min = BigDecimal.ZERO;
+            for (BigDecimal sample : this.samples) {
+                if (min == BigDecimal.ZERO || sample.compareTo(min) < 0) {
+                    min = sample;
+                }
+            }
+            return min.doubleValue();
         }
-        return this.total.divide(BigDecimal.valueOf(this.samples.size()), 30, RoundingMode.HALF_UP).doubleValue();
     }
 
 }