Add LOW_TPS_SPIKES Datapoint

Author: AuroraLS3

Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/auth/WebPermission.java

@@ -176,6 +176,8 @@ public enum WebPermission implements Supplier<String>, Lang {
     DATA_SERVER_DEATHS("See Deaths datapoint of servers"),
     DATA_NETWORK_DEATHS("See Deaths datapoint of network"),
     DATA_SERVER_TPS_AVERAGE("See Average TPS -datapoint of servers"),
+    DATA_SERVER_TPS_LOW_SPIKES("See Low TPS spikes -datapoint of servers"),
+    DATA_NETWORK_TPS_LOW_SPIKES("See Low TPS spikes -datapoint of network"),
     DATA_SERVER_RAM_AVERAGE("See Average RAM -datapoint of servers"),
     DATA_SERVER_MSPT_AVERAGE("See Average MSPT -datapoint of servers"),
     DATA_SERVER_CPU_AVERAGE("See Average CPU -datapoint of servers"),

Plan/common/src/main/java/com/djrapitops/plan/delivery/export/ServerPageExporter.java

@@ -169,6 +169,7 @@ public void exportJSON(Path toDirectory, ServerUUID serverUUID) throws IOExcepti
                 datapointType + DatapointType.DEATHS + server,
                 datapointType + DatapointType.UPTIME_CURRENT + server,
                 datapointType + DatapointType.TPS_AVERAGE + afterMillis + TimeUnit.DAYS.toMillis(7) + server,
+                datapointType + DatapointType.TPS_LOW_SPIKES + afterMillis + TimeUnit.DAYS.toMillis(7) + server,
                 datapointType + DatapointType.UNIQUE_PLAYERS_AVERAGE + afterMillis + TimeUnit.DAYS.toMillis(7) + server,
                 datapointType + DatapointType.NEW_PLAYER_RETENTION + afterMillis + TimeUnit.DAYS.toMillis(7) + server,
                 // Week comparison

Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/DatapointType.java

@@ -57,7 +57,8 @@ public enum DatapointType {
     ENTITIES_AVERAGE(EntitiesAverage.class, DatapointCacheKey.TPS),
     CHUNKS_AVERAGE(ChunksAverage.class, DatapointCacheKey.TPS),
     UNIQUE_PLAYERS_AVERAGE(UniquePlayersPerDayAverage.class, DatapointCacheKey.SESSION),
-    NEW_PLAYER_RETENTION(NewPlayerRetention.class, DatapointCacheKey.SESSION);
+    NEW_PLAYER_RETENTION(NewPlayerRetention.class, DatapointCacheKey.SESSION),
+    TPS_LOW_SPIKES(TPSLowSpikes.class, DatapointCacheKey.TPS);
 
     private final Class<? extends Datapoint<?>> datapointClass;
     private final DatapointCacheKey[] cacheKeys;

Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/types/DatapointModule.java

@@ -145,4 +145,8 @@ public interface DatapointModule {
     @Binds
     @IntoSet
     Datapoint<?> bindNewPlayerRetention(NewPlayerRetention newPlayerRetention);
+
+    @Binds
+    @IntoSet
+    Datapoint<?> bindTPSLowSpikes(TPSLowSpikes tpsLowSpikes);
 }

Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/types/TPSLowSpikes.java

@@ -0,0 +1,81 @@
+/*
+ *  This file is part of Player Analytics (Plan).
+ *
+ *  Plan is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License v3 as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Plan 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 Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with Plan. If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.djrapitops.plan.delivery.rendering.json.datapoint.types;
+
+import com.djrapitops.plan.delivery.domain.auth.WebPermission;
+import com.djrapitops.plan.delivery.domain.datatransfer.GenericFilter;
+import com.djrapitops.plan.delivery.rendering.json.datapoint.Datapoint;
+import com.djrapitops.plan.delivery.rendering.json.datapoint.DatapointType;
+import com.djrapitops.plan.delivery.web.resolver.exception.BadRequestException;
+import com.djrapitops.plan.settings.config.PlanConfig;
+import com.djrapitops.plan.settings.config.paths.DisplaySettings;
+import com.djrapitops.plan.storage.database.DBSystem;
+import com.djrapitops.plan.storage.database.queries.objects.TPSQueries;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import java.util.Optional;
+
+/**
+ * Datapoint for Low TPS spikes.
+ * <p>
+ * Low tps spikes are computed by checking TPS values against a threshold,
+ * only counting each spike as individual spike once previous spike has recovered.
+ *
+ * @author AuroraLS3
+ */
+@Singleton
+public class TPSLowSpikes implements Datapoint<Integer> {
+
+    private final PlanConfig config;
+    private final DBSystem dbSystem;
+
+    @Inject
+    public TPSLowSpikes(PlanConfig config, DBSystem dbSystem) {
+        this.config = config;
+        this.dbSystem = dbSystem;
+    }
+
+    @Override
+    public Optional<Integer> getValue(GenericFilter filter) {
+        if (filter.getPlayerUUID().isPresent()) {
+            throw new BadRequestException("TPS_LOW_SPIKES does not support player parameter");
+        }
+        return Optional.of(dbSystem.getDatabase().query(TPSQueries.lowTpsSpikes(
+                config.get(DisplaySettings.GRAPH_TPS_THRESHOLD_MED),
+                filter.getAfter(),
+                filter.getBefore(),
+                filter.getServerUUIDs()))
+        );
+    }
+
+    @Override
+    public WebPermission getPermission(GenericFilter filter) {
+        if (filter.getPlayerUUID().isPresent()) {
+            return WebPermission.DATA_PLAYER;
+        } else if (!filter.getServerUUIDs().isEmpty()) {
+            return WebPermission.DATA_SERVER_TPS_LOW_SPIKES;
+        } else {
+            return WebPermission.DATA_NETWORK_TPS_LOW_SPIKES;
+        }
+    }
+
+    @Override
+    public DatapointType getType() {
+        return DatapointType.TPS_LOW_SPIKES;
+    }
+}

Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/TPSQueries.java

@@ -184,6 +184,25 @@ public static Query<Map<Integer, Long>> uptime(long after, long before, List<Ser
                 after, before);
     }
 
+    public static Query<Integer> lowTpsSpikes(double threshold, long after, long before, List<ServerUUID> serverUUIDs) {
+        String sql = SELECT + "COUNT(*) as count" + FROM + '(' +
+                SELECT + SERVER_ID + ',' +
+                TPS + ',' +
+                "LAG(" + TPS + ") OVER (PARTITION BY " + SERVER_ID + ORDER_BY + DATE + ") as prev_tps" +
+                FROM + TABLE_NAME +
+                WHERE + DATE + ">=?" +
+                AND + DATE + "<=?" +
+                (serverUUIDs.isEmpty()
+                        ? AND + SERVER_ID + " IN " + ServerTable.selectGameServerIds()
+                        : AND + SERVER_ID + " IN " + ServerTable.selectServerIds(serverUUIDs)) +
+                ") s1" +
+                WHERE + TPS + ">0" +
+                AND + TPS + "<?" +
+                AND + "(prev_tps " + IS_NULL + OR + "prev_tps>=?)";
+        return db -> db.queryOptional(sql, row -> row.getInt("count"), after, before, threshold, threshold)
+                .orElse(0);
+    }
+
     public static Query<List<DateObj<Integer>>> fetchViewPreviewGraphData(ServerUUID serverUUID) {
         String sql = SELECT + min(DATE) + " as " + DATE + ',' +
                 max(PLAYERS_ONLINE) + " as " + PLAYERS_ONLINE +

Plan/common/src/main/java/com/djrapitops/plan/storage/database/sql/tables/ServerTable.java

@@ -95,4 +95,10 @@ public static String selectServerIds(Collection<ServerUUID> serverUUIDs) {
                 uuids(serverUUIDs) +
                 "))";
     }
+
+    public static String selectGameServerIds() {
+        return '(' + SELECT + TABLE_NAME + '.' + ID +
+                FROM + TABLE_NAME +
+                WHERE + TABLE_NAME + '.' + PROXY + "=0)";
+    }
 }

Plan/common/src/test/java/com/djrapitops/plan/delivery/webserver/AccessControlTest.java

@@ -246,6 +246,9 @@ static Stream<Arguments> testCases() {
                 Arguments.of("/v1/datapoint?type=TPS_AVERAGE", WebPermission.DATA_NETWORK, 400, 403),
                 Arguments.of("/v1/datapoint?type=TPS_AVERAGE&server=" + TestConstants.SERVER_UUID_STRING, WebPermission.DATA_SERVER_TPS_AVERAGE, 200, 403),
                 Arguments.of("/v1/datapoint?type=TPS_AVERAGE&player=" + TestConstants.PLAYER_ONE_UUID_STRING, WebPermission.DATA_PLAYER, 400, 403),
+                Arguments.of("/v1/datapoint?type=TPS_LOW_SPIKES", WebPermission.DATA_NETWORK_TPS_LOW_SPIKES, 200, 403),
+                Arguments.of("/v1/datapoint?type=TPS_LOW_SPIKES&server=" + TestConstants.SERVER_UUID_STRING, WebPermission.DATA_SERVER_TPS_LOW_SPIKES, 200, 403),
+                Arguments.of("/v1/datapoint?type=TPS_LOW_SPIKES&player=" + TestConstants.PLAYER_ONE_UUID_STRING, WebPermission.DATA_PLAYER, 400, 403),
                 Arguments.of("/v1/datapoint?type=CPU_AVERAGE", WebPermission.DATA_NETWORK, 400, 403),
                 Arguments.of("/v1/datapoint?type=CPU_AVERAGE&server=" + TestConstants.SERVER_UUID_STRING, WebPermission.DATA_SERVER_CPU_AVERAGE, 200, 403),
                 Arguments.of("/v1/datapoint?type=CPU_AVERAGE&player=" + TestConstants.PLAYER_ONE_UUID_STRING, WebPermission.DATA_PLAYER, 400, 403),

Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/TPSQueriesTest.java

@@ -154,6 +154,20 @@ default void uptimeCalculationMatches() {
         assertEquals(expected, result, () -> "Mismatch (" + expected + ", " + result + ") with data " + data);
     }
 
+    @RepeatedTest(5)
+    default void lowTpsSpikeCalculationMatches() {
+        List<TPS> data = RandomData.randomDateOrderedTPS();
+        for (TPS tps : data) {
+            execute(DataStoreQueries.storeTPS(serverUUID(), tps));
+        }
+
+        data.sort(new TPSComparator());
+        double threshold = RandomData.randomInt(3, 18);
+        Integer expected = new TPSMutator(data).lowTpsSpikeCount(threshold);
+        Integer result = db().query(TPSQueries.lowTpsSpikes(threshold, Long.MIN_VALUE, Long.MAX_VALUE, List.of(serverUUID())));
+        assertEquals(expected, result, () -> "Mismatch (" + expected + ", " + result + ") with data " + data);
+    }
+
     @Test
     default void removeEverythingRemovesTPS() {
         tpsIsStored();

Plan/common/src/testFixtures/java/utilities/RandomData.java

@@ -96,8 +96,9 @@ public static List<TPS> randomDateOrderedTPS() {
         int previousPlayers = randomInt(0, 100);
         for (int i = 0; i < randomInt(50, 100); i++) {
             int randInt = r.nextInt();
+            double randTps = r.nextDouble() * 20;
             long randLong = Math.abs(r.nextLong());
-            test.add(new TPS(previousTimestamp, randLong, randInt, randLong, randLong, randInt, randInt, randLong));
+            test.add(new TPS(previousTimestamp, randTps, randInt, randLong, randLong, randInt, randInt, randLong));
             boolean reboot = Math.random() < 0.10;
             previousTimestamp = previousTimestamp + (reboot ? TimeUnit.MINUTES.toMillis(1) : TimeUnit.MINUTES.toMillis(10));
             previousPlayers = Math.max(previousPlayers + r.nextInt(10) - 10, 0);