Add ping statistics and command

12 files changed, 623 insertions, 177 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 53454aa..c93b876 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
@@ -40,6 +40,8 @@ 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.memory.GarbageCollectorStatistics;
+import me.lucko.spark.common.monitor.ping.PingStatistics;
+import me.lucko.spark.common.monitor.ping.PlayerPingProvider;
 import me.lucko.spark.common.monitor.tick.TickStatistics;
 import me.lucko.spark.common.platform.PlatformStatisticsProvider;
 import me.lucko.spark.common.tick.TickHook;
@@ -99,6 +101,7 @@ public class SparkPlatform {
     private final TickHook tickHook;
     private final TickReporter tickReporter;
     private final TickStatistics tickStatistics;
+    private final PingStatistics pingStatistics;
     private final PlatformStatisticsProvider statisticsProvider;
     private Map<String, GarbageCollectorStatistics> startupGcStatistics = ImmutableMap.of();
     private long serverNormalOperationStartTime;
@@ -136,6 +139,10 @@ public class SparkPlatform {
         this.tickHook = plugin.createTickHook();
         this.tickReporter = plugin.createTickReporter();
         this.tickStatistics = this.tickHook != null ? new TickStatistics() : null;
+
+        PlayerPingProvider pingProvider = plugin.createPlayerPingProvider();
+        this.pingStatistics = pingProvider != null ? new PingStatistics(pingProvider) : null;
+
         this.statisticsProvider = new PlatformStatisticsProvider(this);
     }
 
@@ -152,6 +159,9 @@ public class SparkPlatform {
             this.tickReporter.addCallback(this.tickStatistics);
             this.tickReporter.start();
         }
+        if (this.pingStatistics != null) {
+            this.pingStatistics.start();
+        }
         CpuMonitor.ensureMonitoring();
 
         // poll startup GC statistics after plugins & the world have loaded
@@ -172,6 +182,9 @@ public class SparkPlatform {
         if (this.tickReporter != null) {
             this.tickReporter.close();
         }
+        if (this.pingStatistics != null) {
+            this.pingStatistics.close();
+        }
 
         for (CommandModule module : this.commandModules) {
             module.close();
@@ -231,6 +244,10 @@ public class SparkPlatform {
         return this.tickStatistics;
     }
 
+    public PingStatistics getPingStatistics() {
+        return this.pingStatistics;
+    }
+
     public Map<String, GarbageCollectorStatistics> getStartupGcStatistics() {
         return this.startupGcStatistics;
     }
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 f312916..5feb172 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,6 +22,7 @@ package me.lucko.spark.common;
 
 import me.lucko.spark.api.Spark;
 import me.lucko.spark.common.command.sender.CommandSender;
+import me.lucko.spark.common.monitor.ping.PlayerPingProvider;
 import me.lucko.spark.common.platform.PlatformInfo;
 import me.lucko.spark.common.sampler.ThreadDumper;
 import me.lucko.spark.common.tick.TickHook;
@@ -121,6 +122,17 @@ public interface SparkPlugin {
     }
 
     /**
+     * Creates a player ping provider function.
+     *
+     * <p>Returns {@code null} if the platform does not support querying player pings</p>
+     *
+     * @return the player ping provider function
+     */
+    default PlayerPingProvider createPlayerPingProvider() {
+        return null;
+    }
+
+    /**
      * Gets information for the platform.
      *
      * @return information about the platform
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 b036d21..ea4f140 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
@@ -20,8 +20,6 @@
 
 package me.lucko.spark.common.command.modules;
 
-import com.google.common.base.Strings;
-
 import me.lucko.spark.common.SparkPlatform;
 import me.lucko.spark.common.command.Arguments;
 import me.lucko.spark.common.command.Command;
@@ -31,13 +29,14 @@ import me.lucko.spark.common.command.sender.CommandSender;
 import me.lucko.spark.common.command.tabcomplete.TabCompleter;
 import me.lucko.spark.common.monitor.cpu.CpuMonitor;
 import me.lucko.spark.common.monitor.disk.DiskUsage;
+import me.lucko.spark.common.monitor.ping.PingStatistics;
+import me.lucko.spark.common.monitor.ping.PingSummary;
 import me.lucko.spark.common.monitor.tick.TickStatistics;
 import me.lucko.spark.common.util.FormatUtil;
 import me.lucko.spark.common.util.RollingAverage;
+import me.lucko.spark.common.util.StatisticFormatter;
 
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.TextComponent;
-import net.kyori.adventure.text.format.TextColor;
 
 import java.lang.management.ManagementFactory;
 import java.lang.management.MemoryMXBean;
@@ -46,6 +45,7 @@ import java.lang.management.MemoryType;
 import java.lang.management.MemoryUsage;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Set;
 import java.util.function.Consumer;
 
 import static net.kyori.adventure.text.Component.empty;
@@ -57,7 +57,6 @@ import static net.kyori.adventure.text.format.NamedTextColor.GRAY;
 import static net.kyori.adventure.text.format.NamedTextColor.GREEN;
 import static net.kyori.adventure.text.format.NamedTextColor.RED;
 import static net.kyori.adventure.text.format.NamedTextColor.WHITE;
-import static net.kyori.adventure.text.format.NamedTextColor.YELLOW;
 import static net.kyori.adventure.text.format.TextDecoration.BOLD;
 
 public class HealthModule implements CommandModule {
@@ -72,6 +71,14 @@ public class HealthModule implements CommandModule {
         );
 
         consumer.accept(Command.builder()
+                .aliases("ping")
+                .argumentUsage("player", "username")
+                .executor(HealthModule::ping)
+                .tabCompleter((platform, sender, arguments) -> TabCompleter.completeForOpts(arguments, "--player"))
+                .build()
+        );
+
+        consumer.accept(Command.builder()
                 .aliases("healthreport", "health", "ht")
                 .argumentUsage("memory", null)
                 .executor(HealthModule::healthReport)
@@ -86,11 +93,11 @@ public class HealthModule implements CommandModule {
             resp.replyPrefixed(text("TPS from last 5s, 10s, 1m, 5m, 15m:"));
             resp.replyPrefixed(text()
                     .content(" ")
-                    .append(formatTps(tickStatistics.tps5Sec())).append(text(", "))
-                    .append(formatTps(tickStatistics.tps10Sec())).append(text(", "))
-                    .append(formatTps(tickStatistics.tps1Min())).append(text(", "))
-                    .append(formatTps(tickStatistics.tps5Min())).append(text(", "))
-                    .append(formatTps(tickStatistics.tps15Min()))
+                    .append(StatisticFormatter.formatTps(tickStatistics.tps5Sec())).append(text(", "))
+                    .append(StatisticFormatter.formatTps(tickStatistics.tps10Sec())).append(text(", "))
+                    .append(StatisticFormatter.formatTps(tickStatistics.tps1Min())).append(text(", "))
+                    .append(StatisticFormatter.formatTps(tickStatistics.tps5Min())).append(text(", "))
+                    .append(StatisticFormatter.formatTps(tickStatistics.tps15Min()))
                     .build()
             );
             resp.replyPrefixed(empty());
@@ -99,8 +106,8 @@ public class HealthModule implements CommandModule {
                 resp.replyPrefixed(text("Tick durations (min/med/95%ile/max ms) from last 10s, 1m:"));
                 resp.replyPrefixed(text()
                         .content(" ")
-                        .append(formatTickDurations(tickStatistics.duration10Sec())).append(text(";  "))
-                        .append(formatTickDurations(tickStatistics.duration1Min()))
+                        .append(StatisticFormatter.formatTickDurations(tickStatistics.duration10Sec())).append(text(";  "))
+                        .append(StatisticFormatter.formatTickDurations(tickStatistics.duration1Min()))
                         .build()
                 );
                 resp.replyPrefixed(empty());
@@ -110,22 +117,67 @@ public class HealthModule implements CommandModule {
         resp.replyPrefixed(text("CPU usage from last 10s, 1m, 15m:"));
         resp.replyPrefixed(text()
                 .content(" ")
-                .append(formatCpuUsage(CpuMonitor.systemLoad10SecAvg())).append(text(", "))
-                .append(formatCpuUsage(CpuMonitor.systemLoad1MinAvg())).append(text(", "))
-                .append(formatCpuUsage(CpuMonitor.systemLoad15MinAvg()))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.systemLoad10SecAvg())).append(text(", "))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.systemLoad1MinAvg())).append(text(", "))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.systemLoad15MinAvg()))
                 .append(text("  (system)", DARK_GRAY))
                 .build()
         );
         resp.replyPrefixed(text()
                 .content(" ")
-                .append(formatCpuUsage(CpuMonitor.processLoad10SecAvg())).append(text(", "))
-                .append(formatCpuUsage(CpuMonitor.processLoad1MinAvg())).append(text(", "))
-                .append(formatCpuUsage(CpuMonitor.processLoad15MinAvg()))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.processLoad10SecAvg())).append(text(", "))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.processLoad1MinAvg())).append(text(", "))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.processLoad15MinAvg()))
                 .append(text("  (process)", DARK_GRAY))
                 .build()
         );
     }
 
+    private static void ping(SparkPlatform platform, CommandSender sender, CommandResponseHandler resp, Arguments arguments) {
+        PingStatistics pingStatistics = platform.getPingStatistics();
+        if (pingStatistics == null) {
+            resp.replyPrefixed(text("Ping data is not available on this platform."));
+            return;
+        }
+
+        // lookup for specific player
+        Set<String> players = arguments.stringFlag("player");
+        if (!players.isEmpty()) {
+            for (String player : players) {
+                PingStatistics.PlayerPing playerPing = pingStatistics.query(player);
+                if (playerPing == null) {
+                    resp.replyPrefixed(text("Ping data is not available for '" + player + "'."));
+                } else {
+                    resp.replyPrefixed(text()
+                            .content("Player ")
+                            .append(text(playerPing.name(), WHITE))
+                            .append(text(" has "))
+                            .append(StatisticFormatter.formatPingRtt(playerPing.ping()))
+                            .append(text(" ms ping."))
+                            .build()
+                    );
+                }
+            }
+            return;
+        }
+
+        PingSummary summary = pingStatistics.currentSummary();
+        RollingAverage average = pingStatistics.getPingAverage();
+
+        if (summary.total() == 0 && average.getSamples() == 0) {
+            resp.replyPrefixed(text("There is not enough data to show ping averages yet. Please try again later."));
+            return;
+        }
+
+        resp.replyPrefixed(text("Average Pings (min/med/95%ile/max ms) from now, last 15m:"));
+        resp.replyPrefixed(text()
+                .content(" ")
+                .append(StatisticFormatter.formatPingRtts(summary.min(), summary.median(), summary.percentile95th(), summary.max())).append(text(";  "))
+                .append(StatisticFormatter.formatPingRtts(average.min(), average.median(), average.percentile95th(), average.max()))
+                .build()
+        );
+    }
+
     private static void healthReport(SparkPlatform platform, CommandSender sender, CommandResponseHandler resp, Arguments arguments) {
         resp.replyPrefixed(text("Generating server health report..."));
         List<Component> report = new LinkedList<>();
@@ -159,11 +211,11 @@ public class HealthModule implements CommandModule {
         );
         report.add(text()
                 .content("    ")
-                .append(formatTps(tickStatistics.tps5Sec())).append(text(", "))
-                .append(formatTps(tickStatistics.tps10Sec())).append(text(", "))
-                .append(formatTps(tickStatistics.tps1Min())).append(text(", "))
-                .append(formatTps(tickStatistics.tps5Min())).append(text(", "))
-                .append(formatTps(tickStatistics.tps15Min()))
+                .append(StatisticFormatter.formatTps(tickStatistics.tps5Sec())).append(text(", "))
+                .append(StatisticFormatter.formatTps(tickStatistics.tps10Sec())).append(text(", "))
+                .append(StatisticFormatter.formatTps(tickStatistics.tps1Min())).append(text(", "))
+                .append(StatisticFormatter.formatTps(tickStatistics.tps5Min())).append(text(", "))
+                .append(StatisticFormatter.formatTps(tickStatistics.tps15Min()))
                 .build()
         );
         report.add(empty());
@@ -177,8 +229,8 @@ public class HealthModule implements CommandModule {
             );
             report.add(text()
                     .content("    ")
-                    .append(formatTickDurations(tickStatistics.duration10Sec())).append(text("; "))
-                    .append(formatTickDurations(tickStatistics.duration1Min()))
+                    .append(StatisticFormatter.formatTickDurations(tickStatistics.duration10Sec())).append(text("; "))
+                    .append(StatisticFormatter.formatTickDurations(tickStatistics.duration1Min()))
                     .build()
             );
             report.add(empty());
@@ -194,17 +246,17 @@ public class HealthModule implements CommandModule {
         );
         report.add(text()
                 .content("    ")
-                .append(formatCpuUsage(CpuMonitor.systemLoad10SecAvg())).append(text(", "))
-                .append(formatCpuUsage(CpuMonitor.systemLoad1MinAvg())).append(text(", "))
-                .append(formatCpuUsage(CpuMonitor.systemLoad15MinAvg()))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.systemLoad10SecAvg())).append(text(", "))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.systemLoad1MinAvg())).append(text(", "))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.systemLoad15MinAvg()))
                 .append(text("  (system)", DARK_GRAY))
                 .build()
         );
         report.add(text()
                 .content("    ")
-                .append(formatCpuUsage(CpuMonitor.processLoad10SecAvg())).append(text(", "))
-                .append(formatCpuUsage(CpuMonitor.processLoad1MinAvg())).append(text(", "))
-                .append(formatCpuUsage(CpuMonitor.processLoad15MinAvg()))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.processLoad10SecAvg())).append(text(", "))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.processLoad1MinAvg())).append(text(", "))
+                .append(StatisticFormatter.formatCpuUsage(CpuMonitor.processLoad15MinAvg()))
                 .append(text("  (process)", DARK_GRAY))
                 .build()
         );
@@ -232,7 +284,7 @@ public class HealthModule implements CommandModule {
                 .append(text(")", GRAY))
                 .build()
         );
-        report.add(text().content("    ").append(generateMemoryUsageDiagram(heapUsage, 40)).build());
+        report.add(text().content("    ").append(StatisticFormatter.generateMemoryUsageDiagram(heapUsage, 60)).build());
         report.add(empty());
     }
 
@@ -283,7 +335,7 @@ public class HealthModule implements CommandModule {
                     .append(text(")", GRAY))
                     .build()
             );
-            report.add(text().content("    ").append(generateMemoryPoolDiagram(usage, collectionUsage, 40)).build());
+            report.add(text().content("    ").append(StatisticFormatter.generateMemoryPoolDiagram(usage, collectionUsage, 60)).build());
 
             if (collectionUsage != null) {
                 report.add(text()
@@ -327,127 +379,8 @@ public class HealthModule implements CommandModule {
                 .append(text(")", GRAY))
                 .build()
         );
-        report.add(text().content("    ").append(generateDiskUsageDiagram(used, total, 40)).build());
+        report.add(text().content("    ").append(StatisticFormatter.generateDiskUsageDiagram(used, total, 60)).build());
         report.add(empty());
     }
 
-    public static TextComponent formatTps(double tps) {
-        TextColor color;
-        if (tps > 18.0) {
-            color = GREEN;
-        } else if (tps > 16.0) {
-            color = YELLOW;
-        } else {
-            color = RED;
-        }
-
-        return text((tps > 20.0 ? "*" : "") + Math.min(Math.round(tps * 100.0) / 100.0, 20.0), color);
-    }
-
-    public static TextComponent formatTickDurations(RollingAverage average) {
-        return text()
-                .append(formatTickDuration(average.min()))
-                .append(text('/', GRAY))
-                .append(formatTickDuration(average.median()))
-                .append(text('/', GRAY))
-                .append(formatTickDuration(average.percentile95th()))
-                .append(text('/', GRAY))
-                .append(formatTickDuration(average.max()))
-                .build();
-    }
-
-    public static TextComponent formatTickDuration(double duration) {
-        TextColor color;
-        if (duration >= 50d) {
-            color = RED;
-        } else if (duration >= 40d) {
-            color = YELLOW;
-        } else {
-            color = GREEN;
-        }
-
-        return text(String.format("%.1f", duration), color);
-    }
-
-    public static TextComponent formatCpuUsage(double usage) {
-        TextColor color;
-        if (usage > 0.9) {
-            color = RED;
-        } else if (usage > 0.65) {
-            color = YELLOW;
-        } else {
-            color = GREEN;
-        }
-
-        return text(FormatUtil.percent(usage, 1d), color);
-    }
-
-    private static TextComponent generateMemoryUsageDiagram(MemoryUsage usage, int length) {
-        double used = usage.getUsed();
-        double committed = usage.getCommitted();
-        double max = usage.getMax();
-
-        int usedChars = (int) ((used * length) / max);
-        int committedChars = (int) ((committed * length) / max);
-
-        TextComponent.Builder line = text().content(Strings.repeat("/", usedChars)).color(GRAY);
-        if (committedChars > usedChars) {
-            line.append(text(Strings.repeat(" ", (committedChars - usedChars) - 1)));
-            line.append(text("|", YELLOW));
-        }
-        if (length > committedChars) {
-            line.append(text(Strings.repeat(" ", (length - committedChars))));
-        }
-
-        return text()
-                .append(text("[", DARK_GRAY))
-                .append(line.build())
-                .append(text("]", DARK_GRAY))
-                .build();
-    }
-
-    private static TextComponent generateMemoryPoolDiagram(MemoryUsage usage, MemoryUsage collectionUsage, int length) {
-        double used = usage.getUsed();
-        double collectionUsed = used;
-        if (collectionUsage != null) {
-            collectionUsed = collectionUsage.getUsed();
-        }
-        double committed = usage.getCommitted();
-        double max = usage.getMax();
-
-        int usedChars = (int) ((used * length) / max);
-        int collectionUsedChars = (int) ((collectionUsed * length) / max);
-        int committedChars = (int) ((committed * length) / max);
-
-        TextComponent.Builder line = text().content(Strings.repeat("/", collectionUsedChars)).color(GRAY);
-
-        if (usedChars > collectionUsedChars) {
-            line.append(text("|", RED));
-            line.append(text(Strings.repeat("/", (usedChars - collectionUsedChars) - 1), GRAY));
-        }
-        if (committedChars > usedChars) {
-            line.append(text(Strings.repeat(" ", (committedChars - usedChars) - 1)));
-            line.append(text("|", YELLOW));
-        }
-        if (length > committedChars) {
-            line.append(text(Strings.repeat(" ", (length - committedChars))));
-        }
-
-        return text()
-                .append(text("[", DARK_GRAY))
-                .append(line.build())
-                .append(text("]", 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);
-        return text()
-                .append(text("[", DARK_GRAY))
-                .append(text(line, GRAY))
-                .append(text("]", DARK_GRAY))
-                .build();
-    }
-
 }
diff --git a/spark-common/src/main/java/me/lucko/spark/common/monitor/MonitoringExecutor.java b/spark-common/src/main/java/me/lucko/spark/common/monitor/MonitoringExecutor.java
new file mode 100644
index 0000000..779dbbf
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/monitor/MonitoringExecutor.java
@@ -0,0 +1,16 @@
+package me.lucko.spark.common.monitor;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+public enum MonitoringExecutor {
+    ;
+
+    /** The executor used to monitor & calculate rolling averages. */
+    public static final ScheduledExecutorService INSTANCE = Executors.newSingleThreadScheduledExecutor(r -> {
+        Thread thread = Executors.defaultThreadFactory().newThread(r);
+        thread.setName("spark-monitor");
+        thread.setDaemon(true);
+        return thread;
+    });
+}
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 43e1f90..b4ab831 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,12 +20,11 @@
 
 package me.lucko.spark.common.monitor.cpu;
 
+import me.lucko.spark.common.monitor.MonitoringExecutor;
 import me.lucko.spark.common.util.RollingAverage;
 
 import java.lang.management.ManagementFactory;
 import java.math.BigDecimal;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
 import javax.management.JMX;
@@ -42,13 +41,6 @@ public enum CpuMonitor {
     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");
-        thread.setDaemon(true);
-        return thread;
-    });
 
     // Rolling averages for system/process data
     private static final RollingAverage SYSTEM_AVERAGE_10_SEC = new RollingAverage(10);
@@ -68,7 +60,7 @@ public enum CpuMonitor {
         }
 
         // schedule rolling average calculations.
-        EXECUTOR.scheduleAtFixedRate(new RollingAverageCollectionTask(), 1, 1, TimeUnit.SECONDS);
+        MonitoringExecutor.INSTANCE.scheduleAtFixedRate(new RollingAverageCollectionTask(), 1, 1, TimeUnit.SECONDS);
     }
 
     /**
diff --git a/spark-common/src/main/java/me/lucko/spark/common/monitor/ping/PingStatistics.java b/spark-common/src/main/java/me/lucko/spark/common/monitor/ping/PingStatistics.java
new file mode 100644
index 0000000..8b5b5b3
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/monitor/ping/PingStatistics.java
@@ -0,0 +1,148 @@
+/*
+ * 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.monitor.ping;
+
+import me.lucko.spark.common.monitor.MonitoringExecutor;
+import me.lucko.spark.common.util.RollingAverage;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.math.BigDecimal;
+import java.util.Map;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Provides statistics for player ping RTT to the server.
+ */
+public final class PingStatistics implements Runnable, AutoCloseable {
+    private static final int WINDOW_SIZE_SECONDS = (int) TimeUnit.MINUTES.toSeconds(15);
+    private static final int QUERY_RATE_SECONDS = 10;
+
+    /** The platform function that provides player ping times */
+    private final PlayerPingProvider provider;
+    /** Rolling average of the median ping across all players */
+    private final RollingAverage rollingAverage = new RollingAverage(WINDOW_SIZE_SECONDS / QUERY_RATE_SECONDS);
+
+    /** The scheduler task that polls pings and calculates the rolling average */
+    private ScheduledFuture<?> future;
+
+    public PingStatistics(PlayerPingProvider provider) {
+        this.provider = provider;
+    }
+
+    /**
+     * Starts the statistics monitor
+     */
+    public void start() {
+        if (this.future != null) {
+            throw new IllegalStateException();
+        }
+        this.future = MonitoringExecutor.INSTANCE.scheduleAtFixedRate(this, QUERY_RATE_SECONDS, QUERY_RATE_SECONDS, TimeUnit.SECONDS);
+    }
+
+    @Override
+    public void close() {
+        if (this.future != null) {
+            this.future.cancel(false);
+            this.future = null;
+        }
+    }
+
+    @Override
+    public void run() {
+        PingSummary summary = currentSummary();
+        if (summary.total() == 0) {
+            return;
+        }
+
+        this.rollingAverage.add(BigDecimal.valueOf(summary.median()));
+    }
+
+    /**
+     * Gets the ping rolling average.
+     *
+     * @return the rolling average
+     */
+    public RollingAverage getPingAverage() {
+        return this.rollingAverage;
+    }
+
+    /**
+     * Queries a summary of current player pings.
+     *
+     * @return a summary of current pings
+     */
+    public PingSummary currentSummary() {
+        Map<String, Integer> results = this.provider.poll();
+        int[] values = results.values().stream().filter(ping -> ping > 0).mapToInt(i -> i).toArray();
+        return values.length == 0
+                ? new PingSummary(new int[]{0})
+                : new PingSummary(values);
+    }
+
+    /**
+     * Queries the ping of a given player.
+     *
+     * @param playerName the name of the player
+     * @return the ping, if available
+     */
+    public @Nullable PlayerPing query(String playerName) {
+        Map<String, Integer> results = this.provider.poll();
+
+        // try exact match
+        Integer result = results.get(playerName);
+        if (result != null) {
+            return new PlayerPing(playerName, result);
+        }
+
+        // try case-insensitive match
+        for (Map.Entry<String, Integer> entry : results.entrySet()) {
+            if (entry.getKey().equalsIgnoreCase(playerName)) {
+                return new PlayerPing(
+                        entry.getKey(),
+                        entry.getValue()
+                );
+            }
+        }
+
+        return null;
+    }
+
+    public static final class PlayerPing {
+        private final String name;
+        private final int ping;
+
+        PlayerPing(String name, int ping) {
+            this.name = name;
+            this.ping = ping;
+        }
+
+        public String name() {
+            return this.name;
+        }
+
+        public int ping() {
+            return this.ping;
+        }
+    }
+
+}
diff --git a/spark-common/src/main/java/me/lucko/spark/common/monitor/ping/PingSummary.java b/spark-common/src/main/java/me/lucko/spark/common/monitor/ping/PingSummary.java
new file mode 100644
index 0000000..024d27d
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/monitor/ping/PingSummary.java
@@ -0,0 +1,81 @@
+/*
+ * 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.monitor.ping;
+
+import java.util.Arrays;
+
+public final class PingSummary {
+
+    private final int[] values;
+    private final int total;
+    private final int max;
+    private final int min;
+    private final double mean;
+
+    public PingSummary(int[] values) {
+        Arrays.sort(values);
+        this.values = values;
+
+        int total = 0;
+        for (int value : values) {
+            total += value;
+        }
+        this.total = total;
+
+        this.mean = (double) total / values.length;
+        this.max = values[values.length - 1];
+        this.min = values[0];
+    }
+
+    public int total() {
+        return this.total;
+    }
+
+    public double mean() {
+        return this.mean;
+    }
+
+    public int max() {
+        return this.max;
+    }
+
+    public int min() {
+        return this.min;
+    }
+
+    public int percentile(double percentile) {
+        if (percentile < 0 || percentile > 1) {
+            throw new IllegalArgumentException("Invalid percentile " + percentile);
+        }
+
+        int rank = (int) Math.ceil(percentile * (this.values.length - 1));
+        return this.values[rank];
+    }
+
+    public double median() {
+        return percentile(0.50d);
+    }
+
+    public double percentile95th() {
+        return percentile(0.95d);
+    }
+
+}
diff --git a/spark-common/src/main/java/me/lucko/spark/common/monitor/ping/PlayerPingProvider.java b/spark-common/src/main/java/me/lucko/spark/common/monitor/ping/PlayerPingProvider.java
new file mode 100644
index 0000000..7576573
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/monitor/ping/PlayerPingProvider.java
@@ -0,0 +1,40 @@
+/*
+ * 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.monitor.ping;
+
+import java.util.Map;
+
+/**
+ * Provides information about player ping RTT.
+ */
+@FunctionalInterface
+public interface PlayerPingProvider {
+
+    /**
+     * Poll current player pings in milliseconds.
+     *
+     * <p>The map keys are player names and the values are the ping values.</p>
+     *
+     * @return a map of player pings
+     */
+    Map<String, Integer> poll();
+
+}
diff --git a/spark-common/src/main/java/me/lucko/spark/common/platform/PlatformStatisticsProvider.java b/spark-common/src/main/java/me/lucko/spark/common/platform/PlatformStatisticsProvider.java
index fce45ec..5b8d1d4 100644
--- a/spark-common/src/main/java/me/lucko/spark/common/platform/PlatformStatisticsProvider.java
+++ b/spark-common/src/main/java/me/lucko/spark/common/platform/PlatformStatisticsProvider.java
@@ -26,6 +26,7 @@ import me.lucko.spark.common.monitor.cpu.CpuMonitor;
 import me.lucko.spark.common.monitor.disk.DiskUsage;
 import me.lucko.spark.common.monitor.memory.GarbageCollectorStatistics;
 import me.lucko.spark.common.monitor.memory.MemoryInfo;
+import me.lucko.spark.common.monitor.ping.PingStatistics;
 import me.lucko.spark.common.monitor.tick.TickStatistics;
 import me.lucko.spark.common.util.RollingAverage;
 import me.lucko.spark.proto.SparkProtos.PlatformStatistics;
@@ -148,18 +149,26 @@ public class PlatformStatisticsProvider {
             );
             if (tickStatistics.isDurationSupported()) {
                 builder.setMspt(PlatformStatistics.Mspt.newBuilder()
-                        .setLast1M(msptValues(tickStatistics.duration1Min()))
-                        .setLast5M(msptValues(tickStatistics.duration5Min()))
+                        .setLast1M(rollingAverageValues(tickStatistics.duration1Min()))
+                        .setLast5M(rollingAverageValues(tickStatistics.duration5Min()))
                         .build()
                 );
             }
         }
 
+        PingStatistics pingStatistics = this.platform.getPingStatistics();
+        if (pingStatistics != null && pingStatistics.getPingAverage().getSamples() != 0) {
+            builder.setPing(PlatformStatistics.Ping.newBuilder()
+                    .setLast15M(rollingAverageValues(pingStatistics.getPingAverage()))
+                    .build()
+            );
+        }
+
         return builder.build();
     }
 
-    private static PlatformStatistics.Mspt.Values msptValues(RollingAverage rollingAverage) {
-        return PlatformStatistics.Mspt.Values.newBuilder()
+    private static PlatformStatistics.RollingAverageValues rollingAverageValues(RollingAverage rollingAverage) {
+        return PlatformStatistics.RollingAverageValues.newBuilder()
                 .setMean(rollingAverage.mean())
                 .setMax(rollingAverage.max())
                 .setMin(rollingAverage.min())
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 87c41a4..57dfdff 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
@@ -39,6 +39,12 @@ public class RollingAverage implements DoubleAverageInfo {
         this.samples = new ArrayDeque<>(this.windowSize + 1);
     }
 
+    public int getSamples() {
+        synchronized (this) {
+            return this.samples.size();
+        }
+    }
+
     public void add(BigDecimal num) {
         synchronized (this) {
             this.total = this.total.add(num);
diff --git a/spark-common/src/main/java/me/lucko/spark/common/util/StatisticFormatter.java b/spark-common/src/main/java/me/lucko/spark/common/util/StatisticFormatter.java
new file mode 100644
index 0000000..9a2850e
--- /dev/null
+++ b/spark-common/src/main/java/me/lucko/spark/common/util/StatisticFormatter.java
@@ -0,0 +1,187 @@
+/*
+ * 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 com.google.common.base.Strings;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.format.TextColor;
+
+import java.lang.management.MemoryUsage;
+
+import static net.kyori.adventure.text.Component.text;
+import static net.kyori.adventure.text.format.NamedTextColor.DARK_GRAY;
+import static net.kyori.adventure.text.format.NamedTextColor.GRAY;
+import static net.kyori.adventure.text.format.NamedTextColor.GREEN;
+import static net.kyori.adventure.text.format.NamedTextColor.RED;
+import static net.kyori.adventure.text.format.NamedTextColor.YELLOW;
+
+public enum StatisticFormatter {
+    ;
+
+    private static final String BAR_CHARACTER = "|";
+
+    public static TextComponent formatTps(double tps) {
+        TextColor color;
+        if (tps > 18.0) {
+            color = GREEN;
+        } else if (tps > 16.0) {
+            color = YELLOW;
+        } else {
+            color = RED;
+        }
+
+        return text((tps > 20.0 ? "*" : "") + Math.min(Math.round(tps * 100.0) / 100.0, 20.0), color);
+    }
+
+    public static TextComponent formatTickDurations(RollingAverage average) {
+        return text()
+                .append(formatTickDuration(average.min()))
+                .append(text('/', GRAY))
+                .append(formatTickDuration(average.median()))
+                .append(text('/', GRAY))
+                .append(formatTickDuration(average.percentile95th()))
+                .append(text('/', GRAY))
+                .append(formatTickDuration(average.max()))
+                .build();
+    }
+
+    public static TextComponent formatTickDuration(double duration) {
+        TextColor color;
+        if (duration >= 50d) {
+            color = RED;
+        } else if (duration >= 40d) {
+            color = YELLOW;
+        } else {
+            color = GREEN;
+        }
+
+        return text(String.format("%.1f", duration), color);
+    }
+
+    public static TextComponent formatCpuUsage(double usage) {
+        TextColor color;
+        if (usage > 0.9) {
+            color = RED;
+        } else if (usage > 0.65) {
+            color = YELLOW;
+        } else {
+            color = GREEN;
+        }
+
+        return text(FormatUtil.percent(usage, 1d), color);
+    }
+
+    public static TextComponent formatPingRtts(double min, double median, double percentile95th, double max) {
+        return text()
+                .append(formatPingRtt(min))
+                .append(text('/', GRAY))
+                .append(formatPingRtt(median))
+                .append(text('/', GRAY))
+                .append(formatPingRtt(percentile95th))
+                .append(text('/', GRAY))
+                .append(formatPingRtt(max))
+                .build();
+    }
+
+    public static TextComponent formatPingRtt(double ping) {
+        TextColor color;
+        if (ping >= 200) {
+            color = RED;
+        } else if (ping >= 100) {
+            color = YELLOW;
+        } else {
+            color = GREEN;
+        }
+
+        return text((int) Math.ceil(ping), color);
+    }
+
+    public static TextComponent generateMemoryUsageDiagram(MemoryUsage usage, int length) {
+        double used = usage.getUsed();
+        double committed = usage.getCommitted();
+        double max = usage.getMax();
+
+        int usedChars = (int) ((used * length) / max);
+        int committedChars = (int) ((committed * length) / max);
+
+        TextComponent.Builder line = text().content(Strings.repeat(BAR_CHARACTER, usedChars)).color(YELLOW);
+        if (committedChars > usedChars) {
+            line.append(text(Strings.repeat(BAR_CHARACTER, (committedChars - usedChars) - 1), GRAY));
+            line.append(Component.text(BAR_CHARACTER, RED));
+        }
+        if (length > committedChars) {
+            line.append(text(Strings.repeat(BAR_CHARACTER, (length - committedChars)), GRAY));
+        }
+
+        return text()
+                .append(text("[", DARK_GRAY))
+                .append(line.build())
+                .append(text("]", DARK_GRAY))
+                .build();
+    }
+
+    public static TextComponent generateMemoryPoolDiagram(MemoryUsage usage, MemoryUsage collectionUsage, int length) {
+        double used = usage.getUsed();
+        double collectionUsed = used;
+        if (collectionUsage != null) {
+            collectionUsed = collectionUsage.getUsed();
+        }
+        double committed = usage.getCommitted();
+        double max = usage.getMax();
+
+        int usedChars = (int) ((used * length) / max);
+        int collectionUsedChars = (int) ((collectionUsed * length) / max);
+        int committedChars = (int) ((committed * length) / max);
+
+        TextComponent.Builder line = text().content(Strings.repeat(BAR_CHARACTER, collectionUsedChars)).color(YELLOW);
+
+        if (usedChars > collectionUsedChars) {
+            line.append(Component.text(BAR_CHARACTER, RED));
+            line.append(text(Strings.repeat(BAR_CHARACTER, (usedChars - collectionUsedChars) - 1), YELLOW));
+        }
+        if (committedChars > usedChars) {
+            line.append(text(Strings.repeat(BAR_CHARACTER, (committedChars - usedChars) - 1), GRAY));
+            line.append(Component.text(BAR_CHARACTER, YELLOW));
+        }
+        if (length > committedChars) {
+            line.append(text(Strings.repeat(BAR_CHARACTER, (length - committedChars)), GRAY));
+        }
+
+        return text()
+                .append(text("[", DARK_GRAY))
+                .append(line.build())
+                .append(text("]", DARK_GRAY))
+                .build();
+    }
+
+    public static TextComponent generateDiskUsageDiagram(double used, double max, int length) {
+        int usedChars = (int) ((used * length) / max);
+        int freeChars = length - usedChars;
+        return text()
+                .append(text("[", DARK_GRAY))
+                .append(text(Strings.repeat(BAR_CHARACTER, usedChars), YELLOW))
+                .append(text(Strings.repeat(BAR_CHARACTER, freeChars), GRAY))
+                .append(text("]", DARK_GRAY))
+                .build();
+    }
+}
diff --git a/spark-common/src/main/proto/spark/spark.proto b/spark-common/src/main/proto/spark/spark.proto
index ae04cd7..d800762 100644
--- a/spark-common/src/main/proto/spark/spark.proto
+++ b/spark-common/src/main/proto/spark/spark.proto
@@ -85,6 +85,7 @@ message PlatformStatistics {
   int64 uptime = 3;
   Tps tps = 4; // optional
   Mspt mspt = 5; // optional
+  Ping ping = 6; // optional
 
   message Memory {
     MemoryPool heap = 1;
@@ -108,16 +109,20 @@ message PlatformStatistics {
   }
 
   message Mspt {
-    Values last1m = 1;
-    Values last5m = 2;
-
-    message Values {
-      double mean = 1;
-      double max = 2;
-      double min = 3;
-      double median = 4;
-      double percentile95 = 5;
-    }
+    RollingAverageValues last1m = 1;
+    RollingAverageValues last5m = 2;
+  }
+
+  message Ping {
+    RollingAverageValues last15m = 1;
+  }
+
+  message RollingAverageValues {
+    double mean = 1;
+    double max = 2;
+    double min = 3;
+    double median = 4;
+    double percentile95 = 5;
   }
 }