Change the way CPU monitoring is performed

8 files changed, 264 insertions, 102 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 dd55157..e99cb05 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
@@ -32,6 +32,7 @@ import me.lucko.spark.common.command.modules.SamplerModule;
 import me.lucko.spark.common.command.modules.TickMonitoringModule;
 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.util.BytebinClient;
@@ -95,6 +96,7 @@ public class SparkPlatform {
             this.tickCounter.addTickTask(this.tpsCalculator);
             this.tickCounter.start();
         }
+        CpuMonitor.ensureMonitoring();
     }
 
     public void disable() {
diff --git a/spark-common/src/main/java/me/lucko/spark/common/command/modules/ActivityLogModule.java b/spark-common/src/main/java/me/lucko/spark/common/command/modules/ActivityLogModule.java
index c51fe2c..edb8537 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/command/modules/ActivityLogModule.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/command/modules/ActivityLogModule.java
@@ -68,10 +68,7 @@ public class ActivityLogModule implements CommandModule {
                                 .build()
                         );
 
-                        TextComponent.Builder valueComponent = TextComponent.builder(activity.getDataValue())
-                                .color(TextColor.WHITE)
-                                .decoration(TextDecoration.UNDERLINED, true);
-
+                        TextComponent.Builder valueComponent = TextComponent.builder(activity.getDataValue(), TextColor.WHITE);
                         if (activity.getDataType().equals("url")) {
                             valueComponent.clickEvent(ClickEvent.openUrl(activity.getDataValue()));
                         }
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 f2ae6fc..9c139eb 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
@@ -54,7 +54,14 @@ public class HealthModule implements CommandModule {
                     TpsCalculator tpsCalculator = platform.getTpsCalculator();
                     if (tpsCalculator != null) {
                         resp.replyPrefixed(TextComponent.of("TPS from last 5s, 10s, 1m, 5m, 15m:"));
-                        resp.replyPrefixed(TextComponent.builder(" ").append(tpsCalculator.toFormattedComponent()).build());
+                        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()))
+                                .build()
+                        );
                     } else {
                         resp.replyPrefixed(TextComponent.of("Not supported!"));
                     }
@@ -64,6 +71,29 @@ public class HealthModule implements CommandModule {
         );
 
         consumer.accept(Command.builder()
+                .aliases("cpu")
+                .executor((platform, sender, resp, arguments) -> {
+                    resp.replyPrefixed(TextComponent.of("CPU usage from last 10s, 1m, 15m:"));
+                    resp.replyPrefixed(TextComponent.builder(" ")
+                            .append(formatCpuUsage(CpuMonitor.systemLoad10SecAvg())).append(TextComponent.of(", "))
+                            .append(formatCpuUsage(CpuMonitor.systemLoad1MinAvg())).append(TextComponent.of(", "))
+                            .append(formatCpuUsage(CpuMonitor.systemLoad15MinAvg()))
+                            .append(TextComponent.of("  (system)", TextColor.DARK_GRAY))
+                            .build()
+                    );
+                    resp.replyPrefixed(TextComponent.builder(" ")
+                            .append(formatCpuUsage(CpuMonitor.processLoad10SecAvg())).append(TextComponent.of(", "))
+                            .append(formatCpuUsage(CpuMonitor.processLoad1MinAvg())).append(TextComponent.of(", "))
+                            .append(formatCpuUsage(CpuMonitor.processLoad15MinAvg()))
+                            .append(TextComponent.of("  (process)", TextColor.DARK_GRAY))
+                            .build()
+                    );
+                })
+                .tabCompleter(Command.TabCompleter.empty())
+                .build()
+        );
+
+        consumer.accept(Command.builder()
                 .aliases("healthreport", "health", "ht")
                 .argumentUsage("memory", null)
                 .executor((platform, sender, resp, arguments) -> {
@@ -80,10 +110,39 @@ public class HealthModule implements CommandModule {
                                     .append(TextComponent.of("TPS from last 5s, 10s, 1m, 5m, 15m:", TextColor.GOLD))
                                     .build()
                             );
-                            report.add(TextComponent.builder("    ").append(tpsCalculator.toFormattedComponent()).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()))
+                                    .build()
+                            );
                             report.add(TextComponent.empty());
                         }
 
+                        report.add(TextComponent.builder("")
+                                .append(TextComponent.builder(">").color(TextColor.DARK_GRAY).decoration(TextDecoration.BOLD, true).build())
+                                .append(TextComponent.space())
+                                .append(TextComponent.of("CPU usage from last 10s, 1m, 15m:", TextColor.GOLD))
+                                .build()
+                        );
+                        report.add(TextComponent.builder("    ")
+                                .append(formatCpuUsage(CpuMonitor.systemLoad10SecAvg())).append(TextComponent.of(", "))
+                                .append(formatCpuUsage(CpuMonitor.systemLoad1MinAvg())).append(TextComponent.of(", "))
+                                .append(formatCpuUsage(CpuMonitor.systemLoad15MinAvg()))
+                                .append(TextComponent.of("  (system)", TextColor.DARK_GRAY))
+                                .build()
+                        );
+                        report.add(TextComponent.builder("    ")
+                                .append(formatCpuUsage(CpuMonitor.processLoad10SecAvg())).append(TextComponent.of(", "))
+                                .append(formatCpuUsage(CpuMonitor.processLoad1MinAvg())).append(TextComponent.of(", "))
+                                .append(formatCpuUsage(CpuMonitor.processLoad15MinAvg()))
+                                .append(TextComponent.of("  (process)", TextColor.DARK_GRAY))
+                                .build()
+                        );
+                        report.add(TextComponent.empty());
+
                         MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
                         MemoryUsage heapUsage = memoryMXBean.getHeapMemoryUsage();
                         report.add(TextComponent.builder("")
@@ -168,37 +227,6 @@ public class HealthModule implements CommandModule {
                             }
                         }
 
-                        double systemCpuLoad = CpuMonitor.getSystemCpuLoad();
-                        double processCpuLoad = CpuMonitor.getProcessCpuLoad();
-
-                        if (systemCpuLoad >= 0 || processCpuLoad >= 0) {
-                            report.add(TextComponent.builder("")
-                                    .append(TextComponent.builder(">").color(TextColor.DARK_GRAY).decoration(TextDecoration.BOLD, true).build())
-                                    .append(TextComponent.space())
-                                    .append(TextComponent.of("CPU usage:", TextColor.GOLD))
-                                    .build()
-                            );
-
-                            if (systemCpuLoad >= 0) {
-                                report.add(TextComponent.builder("    ")
-                                        .append(TextComponent.of("System: ", TextColor.GRAY))
-                                        .append(TextComponent.of(percent(systemCpuLoad, 1.0d), TextColor.GREEN))
-                                        .build()
-                                );
-                                report.add(TextComponent.builder("    ").append(generateCpuUsageDiagram(systemCpuLoad, 40)).build());
-                                report.add(TextComponent.empty());
-                            }
-                            if (processCpuLoad >= 0) {
-                                report.add(TextComponent.builder("    ")
-                                        .append(TextComponent.of("Process: ", TextColor.GRAY))
-                                        .append(TextComponent.of(percent(processCpuLoad, 1.0d), TextColor.GREEN))
-                                        .build()
-                                );
-                                report.add(TextComponent.builder("    ").append(generateCpuUsageDiagram(processCpuLoad, 40)).build());
-                                report.add(TextComponent.empty());
-                            }
-                        }
-
                         try {
                             FileStore fileStore = Files.getFileStore(Paths.get("."));
                             long totalSpace = fileStore.getTotalSpace();
@@ -242,6 +270,32 @@ public class HealthModule implements CommandModule {
         return (int) percent + "%";
     }
 
+    private static TextComponent formatTps(double tps) {
+        TextColor color;
+        if (tps > 18.0) {
+            color = TextColor.GREEN;
+        } else if (tps > 16.0) {
+            color = TextColor.YELLOW;
+        } else {
+            color = TextColor.RED;
+        }
+
+        return TextComponent.of( (tps > 20.0 ? "*" : "") + Math.min(Math.round(tps * 100.0) / 100.0, 20.0), color);
+    }
+
+    private static TextComponent formatCpuUsage(double usage) {
+        TextColor color;
+        if (usage > 0.9) {
+            color = TextColor.RED;
+        } else if (usage > 0.65) {
+            color = TextColor.YELLOW;
+        } else {
+            color = TextColor.GREEN;
+        }
+
+        return TextComponent.of(percent(usage, 1d), color);
+    }
+
     private static TextComponent generateMemoryUsageDiagram(MemoryUsage usage, int length) {
         double used = usage.getUsed();
         double committed = usage.getCommitted();
@@ -300,16 +354,6 @@ public class HealthModule implements CommandModule {
                 .build();
     }
 
-    private static TextComponent generateCpuUsageDiagram(double usage, int length) {
-        int usedChars = (int) ((usage * length));
-        String line = Strings.repeat("/", usedChars) + Strings.repeat(" ", length - usedChars);
-        return TextComponent.builder("")
-                .append(TextComponent.of("[", TextColor.DARK_GRAY))
-                .append(TextComponent.of(line, TextColor.GRAY))
-                .append(TextComponent.of("]", TextColor.DARK_GRAY))
-                .build();
-    }
-
     private static TextComponent generateDiskUsageDiagram(double used, double max, int length) {
         int usedChars = (int) ((used * length) / max);
         String line = Strings.repeat("/", usedChars) + Strings.repeat(" ", length - usedChars);
diff --git a/spark-common/src/main/java/me/lucko/spark/common/command/modules/MemoryModule.java b/spark-common/src/main/java/me/lucko/spark/common/command/modules/MemoryModule.java
index 42c03d0..f5854f0 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/command/modules/MemoryModule.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/command/modules/MemoryModule.java
@@ -65,7 +65,7 @@ public class MemoryModule implements CommandModule {
                             return;
                         }
 
-                        byte[] output = heapDump.formCompressedDataPayload();
+                        byte[] output = heapDump.formCompressedDataPayload(sender);
                         try {
                             String key = SparkPlatform.BYTEBIN_CLIENT.postContent(output, JSON_TYPE, false).key();
                             String url = SparkPlatform.VIEWER_URL + key;
@@ -120,7 +120,7 @@ public class MemoryModule implements CommandModule {
                         }
 
                         resp.broadcastPrefixed(TextComponent.builder("Heap dump written to: ", TextColor.GOLD)
-                                .append(TextComponent.of(file.toString(), TextColor.DARK_GRAY))
+                                .append(TextComponent.of(file.toString(), TextColor.GRAY))
                                 .build()
                         );
                         platform.getActivityLog().addToLog(Activity.fileActivity(sender, System.currentTimeMillis(), "Heap dump", file.toString()));
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 4ea6144..4b7baae 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
@@ -228,8 +228,9 @@ public class SamplerModule implements CommandModule {
                         return Collections.emptyList();
                     }
 
-                    List<String> opts = new ArrayList<>(Arrays.asList("--timeout", "--regex", "--combine-all",
-                            "--not-combined", "--interval", "--only-ticks-over", "--include-line-numbers"));
+                    List<String> opts = new ArrayList<>(Arrays.asList("--info", "--stop", "--cancel",
+                            "--timeout", "--regex", "--combine-all", "--not-combined", "--interval",
+                            "--only-ticks-over", "--include-line-numbers"));
                     opts.removeAll(arguments);
                     opts.add("--thread"); // allowed multiple times
 
@@ -243,7 +244,7 @@ public class SamplerModule implements CommandModule {
 
     private void handleUpload(SparkPlatform platform, CommandResponseHandler resp, Sampler sampler) {
         platform.getPlugin().runAsync(() -> {
-            byte[] output = sampler.formCompressedDataPayload();
+            byte[] output = sampler.formCompressedDataPayload(resp.sender());
             try {
                 String key = SparkPlatform.BYTEBIN_CLIENT.postContent(output, JSON_TYPE, false).key();
                 String url = SparkPlatform.VIEWER_URL + key;
diff --git a/spark-common/src/main/java/me/lucko/spark/common/monitor/cpu/CpuMonitor.java b/spark-common/src/main/java/me/lucko/spark/common/monitor/cpu/CpuMonitor.java
index 20d71ef..f4190e5 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/monitor/cpu/CpuMonitor.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/monitor/cpu/CpuMonitor.java
@@ -20,25 +20,60 @@
 
 package me.lucko.spark.common.monitor.cpu;
 
+import me.lucko.spark.common.util.RollingAverage;
+
 import javax.management.JMX;
 import javax.management.MBeanServer;
 import javax.management.ObjectName;
 import java.lang.management.ManagementFactory;
+import java.math.BigDecimal;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 
+/**
+ * Exposes and monitors the system/process CPU usage.
+ */
 public final class CpuMonitor {
     private CpuMonitor() {}
 
     /** The object name of the com.sun.management.OperatingSystemMXBean */
     private static final String OPERATING_SYSTEM_BEAN = "java.lang:type=OperatingSystem";
+    /** The OperatingSystemMXBean instance */
+    private static final OperatingSystemMXBean BEAN;
+    /** The executor used to monitor & calculate rolling averages. */
+    private static final ScheduledExecutorService EXECUTOR = Executors.newSingleThreadScheduledExecutor(r -> {
+        Thread thread = Executors.defaultThreadFactory().newThread(r);
+        thread.setName("spark-cpu-monitor");
+        return thread;
+    });
 
-    private static OperatingSystemMXBean getBean() {
+    // Rolling averages for system/process data
+    private static final RollingAverage SYSTEM_AVERAGE_10_SEC = new RollingAverage(10);
+    private static final RollingAverage SYSTEM_AVERAGE_1_MIN = new RollingAverage(60);
+    private static final RollingAverage SYSTEM_AVERAGE_15_MIN = new RollingAverage(60 * 15);
+    private static final RollingAverage PROCESS_AVERAGE_10_SEC = new RollingAverage(10);
+    private static final RollingAverage PROCESS_AVERAGE_1_MIN = new RollingAverage(60);
+    private static final RollingAverage PROCESS_AVERAGE_15_MIN = new RollingAverage(60 * 15);
+
+    static {
         try {
             MBeanServer beanServer = ManagementFactory.getPlatformMBeanServer();
             ObjectName diagnosticBeanName = ObjectName.getInstance(OPERATING_SYSTEM_BEAN);
-            return JMX.newMXBeanProxy(beanServer, diagnosticBeanName, OperatingSystemMXBean.class);
+            BEAN = JMX.newMXBeanProxy(beanServer, diagnosticBeanName, OperatingSystemMXBean.class);
         } catch (Exception e) {
-            throw new RuntimeException(e);
+            throw new UnsupportedOperationException("OperatingSystemMXBean is not supported by the system", e);
         }
+
+        // schedule rolling average calculations.
+        EXECUTOR.scheduleAtFixedRate(new RollingAverageCollectionTask(), 1, 1, TimeUnit.SECONDS);
+    }
+
+    /**
+     * Ensures that the static initializer has been called.
+     */
+    public static void ensureMonitoring() {
+        // intentionally empty
     }
 
     /**
@@ -54,8 +89,20 @@ public final class CpuMonitor {
      * @return the "recent cpu usage" for the whole system; a negative
      * value if not available.
      */
-    public static double getSystemCpuLoad() {
-        return getBean().getSystemCpuLoad();
+    public static double systemLoad() {
+        return BEAN.getSystemCpuLoad();
+    }
+
+    public static double systemLoad10SecAvg() {
+        return SYSTEM_AVERAGE_10_SEC.getAverage();
+    }
+
+    public static double systemLoad1MinAvg() {
+        return SYSTEM_AVERAGE_1_MIN.getAverage();
+    }
+
+    public static double systemLoad15MinAvg() {
+        return SYSTEM_AVERAGE_15_MIN.getAverage();
     }
 
     /**
@@ -73,8 +120,49 @@ public final class CpuMonitor {
      * @return the "recent cpu usage" for the Java Virtual Machine process;
      * a negative value if not available.
      */
-    public static double getProcessCpuLoad() {
-        return getBean().getProcessCpuLoad();
+    public static double processLoad() {
+        return BEAN.getProcessCpuLoad();
+    }
+
+    public static double processLoad10SecAvg() {
+        return PROCESS_AVERAGE_10_SEC.getAverage();
+    }
+
+    public static double processLoad1MinAvg() {
+        return PROCESS_AVERAGE_1_MIN.getAverage();
+    }
+
+    public static double processLoad15MinAvg() {
+        return PROCESS_AVERAGE_15_MIN.getAverage();
+    }
+
+    /**
+     * Task to poll CPU loads and add to the rolling averages in the enclosing class.
+     */
+    private static final class RollingAverageCollectionTask implements Runnable {
+        private final RollingAverage[] systemAverages = new RollingAverage[]{
+                SYSTEM_AVERAGE_10_SEC,
+                SYSTEM_AVERAGE_1_MIN,
+                SYSTEM_AVERAGE_15_MIN
+        };
+        private final RollingAverage[] processAverages = new RollingAverage[]{
+                PROCESS_AVERAGE_10_SEC,
+                PROCESS_AVERAGE_1_MIN,
+                PROCESS_AVERAGE_15_MIN
+        };
+
+        @Override
+        public void run() {
+            BigDecimal systemCpuLoad = new BigDecimal(systemLoad());
+            BigDecimal processCpuLoad = new BigDecimal(processLoad());
+
+            for (RollingAverage average : this.systemAverages) {
+                average.add(systemCpuLoad);
+            }
+            for (RollingAverage average : this.processAverages) {
+                average.add(processCpuLoad);
+            }
+        }
     }
 
     public interface OperatingSystemMXBean {
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/TpsCalculator.java
index 2278e0c..3000523 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/TpsCalculator.java
@@ -21,8 +21,6 @@
 package me.lucko.spark.common.monitor.tick;
 
 import me.lucko.spark.common.sampler.TickCounter;
-import net.kyori.text.TextComponent;
-import net.kyori.text.format.TextColor;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
@@ -46,14 +44,14 @@ public class TpsCalculator implements TickCounter.TickTask {
     private static final int SAMPLE_INTERVAL = 20;
     private static final BigDecimal TPS_BASE = new BigDecimal(SEC_IN_NANO).multiply(new BigDecimal((long) SAMPLE_INTERVAL));
 
-    private final RollingAverage tps5S = new RollingAverage(5);
-    private final RollingAverage tps10S = new RollingAverage(10);
-    private final RollingAverage tps1M = new RollingAverage(60);
-    private final RollingAverage tps5M = new RollingAverage(60 * 5);
-    private final RollingAverage tps15M = new RollingAverage(60 * 15);
+    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 RollingAverage[] averages = new RollingAverage[]{
-            this.tps5S, this.tps10S, this.tps1M, this.tps5M, this.tps15M
+    private final TpsRollingAverage[] averages = new TpsRollingAverage[]{
+            this.avg5Sec, this.avg10Sec, this.avg1Min, this.avg5Min, this.avg15Min
     };
 
     private long last = 0;
@@ -75,55 +73,34 @@ public class TpsCalculator implements TickCounter.TickTask {
         long diff = now - this.last;
         BigDecimal currentTps = TPS_BASE.divide(new BigDecimal(diff), 30, RoundingMode.HALF_UP);
 
-        for (RollingAverage rollingAverage : this.averages) {
+        for (TpsRollingAverage rollingAverage : this.averages) {
             rollingAverage.add(currentTps, diff);
         }
 
         this.last = now;
     }
 
-    public RollingAverage avg5Sec() {
-        return this.tps5S;
+    public double avg5Sec() {
+        return this.avg5Sec.getAverage();
     }
 
-    public RollingAverage avg10Sec() {
-        return this.tps10S;
+    public double avg10Sec() {
+        return this.avg10Sec.getAverage();
     }
 
-    public RollingAverage avg1Min() {
-        return this.tps1M;
+    public double avg1Min() {
+        return this.avg1Min.getAverage();
     }
 
-    public RollingAverage avg5Min() {
-        return this.tps5M;
+    public double avg5Min() {
+        return this.avg5Min.getAverage();
     }
 
-    public RollingAverage avg15Min() {
-        return this.tps15M;
+    public double avg15Min() {
+        return this.avg15Min.getAverage();
     }
 
-    public TextComponent toFormattedComponent() {
-        return TextComponent.builder("")
-                .append(format(this.tps5S.getAverage())).append(TextComponent.of(", "))
-                .append(format(this.tps10S.getAverage())).append(TextComponent.of(", "))
-                .append(format(this.tps1M.getAverage())).append(TextComponent.of(", "))
-                .append(format(this.tps5M.getAverage())).append(TextComponent.of(", "))
-                .append(format(this.tps15M.getAverage()))
-                .build();
-    }
-
-    private static TextComponent format(double tps) {
-        TextColor color;
-        if (tps > 18.0) {
-            color = TextColor.GREEN;
-        } else if (tps > 16.0) {
-            color = TextColor.YELLOW;
-        } else {
-            color = TextColor.RED;
-        }
 
-        return TextComponent.of( (tps > 20.0 ? "*" : "") + Math.min(Math.round(tps * 100.0) / 100.0, 20.0), color);
-    }
 
     /**
      * Rolling average calculator taken.
@@ -132,7 +109,7 @@ public class TpsCalculator implements TickCounter.TickTask {
      *
      * @author aikar (PaperMC) https://github.com/PaperMC/Paper/blob/master/Spigot-Server-Patches/0021-Further-improve-server-tick-loop.patch
      */
-    public static final class RollingAverage {
+    public static final class TpsRollingAverage {
         private final int size;
         private long time;
         private BigDecimal total;
@@ -140,7 +117,7 @@ public class TpsCalculator implements TickCounter.TickTask {
         private final BigDecimal[] samples;
         private final long[] times;
 
-        RollingAverage(int size) {
+        TpsRollingAverage(int size) {
             this.size = size;
             this.time = size * SEC_IN_NANO;
             this.total = new BigDecimal((long) TPS).multiply(new BigDecimal(SEC_IN_NANO)).multiply(new BigDecimal((long) size));
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
new file mode 100644
index 0000000..5b1fd21
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/util/RollingAverage.java
@@ -0,0 +1,53 @@
+/*
+ * 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.util;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+public class RollingAverage {
+
+    private final Queue<BigDecimal> samples = new ArrayDeque<>();
+    private final int size;
+    private BigDecimal total = BigDecimal.ZERO;
+
+    public RollingAverage(int size) {
+        this.size = size;
+    }
+
+    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());
+        }
+    }
+
+    public double getAverage() {
+        if (this.samples.isEmpty()) {
+            return 0;
+        }
+        return this.total.divide(BigDecimal.valueOf(this.samples.size()), 30, RoundingMode.HALF_UP).doubleValue();
+    }
+
+}