Split pregen queue metrics

- Publish in-flight pregen chunk requests as iris.pregen-queue
- Publish chunks left in the job as iris.pregen-remaining
- Mark generation timings unavailable after 10 seconds without generation

adapters/bukkit/plugin/src/test/java/art/arcane/iris/generation/runtime/GenerationRateWindowTest.java

@@ -0,0 +1,46 @@
+package art.arcane.iris.generation.runtime;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class GenerationRateWindowTest {
+    @Test
+    public void generationTimingsGoStaleOnceChunksStopGenerating() {
+        GenerationRateWindow window = new GenerationRateWindow();
+
+        window.sampleChunksPerSecond(0, 1_000L);
+        assertEquals(20D, window.sampleChunksPerSecond(20, 2_000L), 0D);
+        assertTrue(window.generationTimingsFresh(2_000L));
+
+        assertEquals(0D, window.sampleChunksPerSecond(20, 7_000L), 0D);
+        assertTrue(window.generationTimingsFresh(7_000L));
+        assertEquals(0D, window.sampleChunksPerSecond(20, 12_001L), 0D);
+        assertFalse(window.generationTimingsFresh(12_001L));
+
+        window.sampleChunksPerSecond(21, 13_001L);
+        assertTrue(window.generationTimingsFresh(13_001L));
+    }
+
+    @Test
+    public void anIdleWorldNeverPublishesTimings() {
+        GenerationRateWindow window = new GenerationRateWindow();
+
+        window.sampleChunksPerSecond(0, 1_000L);
+        window.sampleChunksPerSecond(0, 2_000L);
+
+        assertFalse(window.generationTimingsFresh(2_000L));
+    }
+
+    @Test
+    public void chunksGeneratedBeforeTheFirstSampleCountAsRecentGeneration() {
+        GenerationRateWindow window = new GenerationRateWindow();
+
+        assertEquals(0D, window.sampleChunksPerSecond(400, 5_000L), 0D);
+
+        assertTrue(window.generationTimingsFresh(5_000L));
+        assertFalse(window.generationTimingsFresh(5_000L + GenerationRateWindow.TIMING_IDLE_MILLIS + 1L));
+    }
+}

adapters/bukkit/plugin/src/test/java/art/arcane/iris/integration/IrisIntegrationServiceTest.java

@@ -49,6 +49,7 @@ public class IrisIntegrationServiceTest {
                         100L,
                         200L,
                         100L,
+                        48L,
                         8D,
                         2_000L,
                         5_000L,
@@ -64,6 +65,8 @@ public class IrisIntegrationServiceTest {
                 IntegrationMetricSchema.IRIS_LOADED_CHUNKS,
                 IntegrationMetricSchema.IRIS_CHUNKS_GENERATED_TOTAL,
                 IntegrationMetricSchema.IRIS_PREGEN_THROUGHPUT,
+                IntegrationMetricSchema.IRIS_PREGEN_QUEUE,
+                IntegrationMetricSchema.IRIS_PREGEN_REMAINING,
                 IntegrationMetricSchema.IRIS_GENERATION_TOTAL_MS,
                 "iris.unsupported"
         ));
@@ -73,6 +76,8 @@ public class IrisIntegrationServiceTest {
         assertEquals(20D, value(samples, IntegrationMetricSchema.IRIS_LOADED_CHUNKS), 0D);
         assertEquals(50D, value(samples, IntegrationMetricSchema.IRIS_CHUNKS_GENERATED_TOTAL), 0D);
         assertEquals(8D, value(samples, IntegrationMetricSchema.IRIS_PREGEN_THROUGHPUT), 0D);
+        assertEquals(48D, value(samples, IntegrationMetricSchema.IRIS_PREGEN_QUEUE), 0D);
+        assertEquals(100D, value(samples, IntegrationMetricSchema.IRIS_PREGEN_REMAINING), 0D);
         assertEquals(4D, value(samples, IntegrationMetricSchema.IRIS_GENERATION_TOTAL_MS), 0D);
         assertFalse(samples.get("iris.unsupported").available());
         assertEquals("unsupported-key", samples.get("iris.unsupported").message());
@@ -84,9 +89,32 @@ public class IrisIntegrationServiceTest {
         assertEquals("minecraft:overworld", overworld.scopeId());
         assertEquals(1D, value(overworld.samples(), IntegrationMetricSchema.IRIS_PREGEN_ACTIVE), 0D);
         assertEquals(8D, value(overworld.samples(), IntegrationMetricSchema.IRIS_PREGEN_THROUGHPUT), 0D);
+        assertEquals(48D, value(overworld.samples(), IntegrationMetricSchema.IRIS_PREGEN_QUEUE), 0D);
+        assertEquals(100D, value(overworld.samples(), IntegrationMetricSchema.IRIS_PREGEN_REMAINING), 0D);
         assertEquals("minecraft:the_nether", nether.scopeId());
         assertEquals(0D, value(nether.samples(), IntegrationMetricSchema.IRIS_PREGEN_ACTIVE), 0D);
         assertFalse(nether.samples().get(IntegrationMetricSchema.IRIS_PREGEN_QUEUE).available());
+        assertFalse(nether.samples().get(IntegrationMetricSchema.IRIS_PREGEN_REMAINING).available());
+    }
+
+    @Test
+    public void idleWorldsPublishGenerationTimingsAsUnavailable() {
+        long now = System.currentTimeMillis();
+        EngineTelemetrySnapshot idle = new EngineTelemetrySnapshot(
+                now, "minecraft:overworld", "world", "dimension", true, false, false, false,
+                12L, 3L, 0.25D, 20L, 20L, 0D, 0L, 2, 0, 1L, 4L, 1L, 10D, Map.of());
+        IrisIntegrationService service = new IrisIntegrationService(
+                () -> telemetry(List.of(idle), IrisTelemetrySnapshot.PregenSnapshot.INACTIVE, now)
+        );
+
+        IntegrationMetricSample total = service.sampleMetrics(Set.of(IntegrationMetricSchema.IRIS_GENERATION_TOTAL_MS))
+                .get(IntegrationMetricSchema.IRIS_GENERATION_TOTAL_MS);
+        IntegrationMetricSample worldTotal = service.metricGroups().get(0).samples()
+                .get(IntegrationMetricSchema.IRIS_GENERATION_TOTAL_MS);
+
+        assertFalse(total.available());
+        assertEquals("timing-not-available", total.message());
+        assertFalse(worldTotal.available());
     }
 
     @Test