Fixes #12706 - Export ArrayByteBufferPool statistics via JMX.

* Exposed bucket statistics as a list of maps.
* Exposed non-bucket statistic map.
* Fixed get[Direct|Heap]Memory() and exposed getAvailable[Direct|Heap]Memory().

Signed-off-by: Simone Bordet <[email protected]>

Author: sbordet

jetty-core/jetty-io/src/main/java/org/eclipse/jetty/io/ArrayByteBufferPool.java

@@ -16,10 +16,13 @@
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.lang.reflect.RecordComponent;
 import java.nio.ByteBuffer;
 import java.time.Instant;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -29,6 +32,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.LongAdder;
 import java.util.function.IntUnaryOperator;
+import java.util.function.ToLongFunction;
 import java.util.stream.Collectors;
 
 import org.eclipse.jetty.io.internal.CompoundPool;
@@ -333,7 +337,7 @@ private void checkMaxMemory(RetainedBucket bucket, boolean direct)
             return;
         try
         {
-            long memory = getMemory(direct);
+            long memory = getTotalMemory(direct);
             long excess = memory - max;
             if (excess > 0)
             {
@@ -418,34 +422,81 @@ private long getAvailableByteBufferCount(boolean direct)
         return Arrays.stream(buckets).mapToLong(bucket -> bucket.getPool().getIdleCount()).sum();
     }
 
-    @ManagedAttribute("The bytes retained by direct ByteBuffers")
+    @ManagedAttribute("The total bytes retained by direct ByteBuffers")
     public long getDirectMemory()
     {
-        return getMemory(true);
+        return getTotalMemory(true);
     }
 
-    @ManagedAttribute("The bytes retained by heap ByteBuffers")
+    @ManagedAttribute("The total bytes retained by heap ByteBuffers")
     public long getHeapMemory()
     {
-        return getMemory(false);
+        return getTotalMemory(false);
     }
 
-    private long getMemory(boolean direct)
+    private long getTotalMemory(boolean direct)
+    {
+        return getMemory(direct, bucket -> bucket.getPool().size());
+    }
+
+    private long getMemory(boolean direct, ToLongFunction<RetainedBucket> count)
     {
         long size = 0;
         for (RetainedBucket bucket : direct ? _direct : _indirect)
-            size += (long)bucket.getPool().getIdleCount() * bucket.getCapacity();
+            size += count.applyAsLong(bucket) * bucket.getCapacity();
         return size;
     }
 
+    @ManagedAttribute("The available bytes retained by direct ByteBuffers")
     public long getAvailableDirectMemory()
     {
-        return getDirectMemory();
+        return getAvailableMemory(true);
     }
 
+    @ManagedAttribute("The available bytes retained by heap ByteBuffers")
     public long getAvailableHeapMemory()
     {
-        return getHeapMemory();
+        return getAvailableMemory(false);
+    }
+
+    private long getAvailableMemory(boolean direct)
+    {
+        return getMemory(direct, bucket -> bucket.getPool().getIdleCount());
+    }
+
+    @ManagedAttribute("The heap buckets statistics")
+    public List<Map<String, Object>> getHeapBucketsStatistics()
+    {
+        return getBucketsStatistics(false);
+    }
+
+    @ManagedAttribute("The direct buckets statistics")
+    public List<Map<String, Object>> getDirectBucketsStatistics()
+    {
+        return getBucketsStatistics(true);
+    }
+
+    private List<Map<String, Object>> getBucketsStatistics(boolean direct)
+    {
+        RetainedBucket[] buckets = direct ? _direct : _indirect;
+        return Arrays.stream(buckets).map(b -> b.getStatistics().toMap()).toList();
+    }
+
+    @ManagedAttribute("The acquires for direct non-pooled bucket capacities")
+    public Map<Integer, Long> getNoBucketDirectAcquires()
+    {
+        return getNoBucketAcquires(true);
+    }
+
+    @ManagedAttribute("The acquires for heap non-pooled bucket capacities")
+    public Map<Integer, Long> getNoBucketHeapAcquires()
+    {
+        return getNoBucketAcquires(false);
+    }
+
+    private Map<Integer, Long> getNoBucketAcquires(boolean direct)
+    {
+        return new HashMap<>(direct ? _noBucketDirectAcquires : _noBucketIndirectAcquires);
     }
 
     @ManagedOperation(value = "Clears this ByteBufferPool", impact = "ACTION")
@@ -475,7 +526,7 @@ public void dump(Appendable out, String indent) throws IOException
             DumpableCollection.fromArray("direct", _direct),
             new DumpableMap("direct non-pooled acquisitions", _noBucketDirectAcquires),
             DumpableCollection.fromArray("indirect", _indirect),
-            new DumpableMap("indirect non-pooled acquisitions", _noBucketIndirectAcquires)
+            new DumpableMap("heap non-pooled acquisitions", _noBucketIndirectAcquires)
         );
     }
 
@@ -576,6 +627,17 @@ private int evict()
             return getCapacity();
         }
 
+        private Statistics getStatistics()
+        {
+            List<Pool.Entry<RetainableByteBuffer>> entries = getPool().stream().toList();
+            int inUse = (int)entries.stream().filter(Pool.Entry::isInUse).count();
+            long pooled = _pooled.longValue();
+            long acquires = _acquires.longValue();
+            float hitRatio = acquires == 0 ? Float.NaN : pooled * 100F / acquires;
+            return new Statistics(getCapacity(), inUse, entries.size(), pooled, acquires, _releases.longValue(),
+                hitRatio, _nonPooled.longValue(), _evicts.longValue(), _removes.longValue());
+        }
+
         public void clear()
         {
             _acquires.reset();
@@ -590,31 +652,45 @@ public void clear()
         @Override
         public String toString()
         {
-            int entries = 0;
-            int inUse = 0;
-            for (Pool.Entry<RetainableByteBuffer> entry : getPool().stream().toList())
+            return String.format("%s[%s]", super.toString(), getStatistics());
+        }
+
+        private record Statistics(int capacity, int inUseEntries, int totalEntries, long pooled, long acquires,
+                                  long releases, float hitRatio, long nonPooled, long evicts, long removes)
+        {
+            private Map<String, Object> toMap()
             {
-                entries++;
-                if (entry.isInUse())
-                    inUse++;
+                try
+                {
+                    Map<String, Object> statistics = new HashMap<>();
+                    for (RecordComponent c : getClass().getRecordComponents())
+                    {
+                        statistics.put(c.getName(), c.getAccessor().invoke(this));
+                    }
+                    return statistics;
+                }
+                catch (Throwable x)
+                {
+                    return Map.of();
+                }
             }
 
-            long pooled = _pooled.longValue();
-            long acquires = _acquires.longValue();
-            float hitRatio = acquires == 0 ? Float.NaN : pooled * 100F / acquires;
-            return String.format("%s{capacity=%d,in-use=%d/%d,pooled/acquires=%d/%d(%.3f%%),non-pooled/evicts/removes/releases=%d/%d/%d/%d}",
-                super.toString(),
-                getCapacity(),
-                inUse,
-                entries,
-                pooled,
-                acquires,
-                hitRatio,
-                _nonPooled.longValue(),
-                _evicts.longValue(),
-                _removes.longValue(),
-                _releases.longValue()
-            );
+            @Override
+            public String toString()
+            {
+                return "capacity=%d,in-use=%d/%d,pooled/acquires/releases=%d/%d/%d(%.3f%%),non-pooled/evicts/removes=%d/%d/%d".formatted(
+                    capacity,
+                    inUseEntries,
+                    totalEntries,
+                    pooled,
+                    acquires,
+                    releases,
+                    hitRatio,
+                    nonPooled,
+                    evicts,
+                    removes
+                );
+            }
         }
 
         private static class BucketCompoundPool extends CompoundPool<RetainableByteBuffer>

jetty-core/jetty-io/src/test/java/org/eclipse/jetty/io/ArrayByteBufferPoolTest.java

@@ -17,6 +17,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
 import org.eclipse.jetty.io.internal.CompoundPool;
 import org.eclipse.jetty.util.ConcurrentPool;
@@ -33,6 +34,7 @@
 import static org.hamcrest.Matchers.notNullValue;
 import static org.hamcrest.Matchers.sameInstance;
 import static org.hamcrest.core.Is.is;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -121,6 +123,7 @@ public void testBelowMinCapacityDoesNotPool()
     public void testOverMaxCapacityDoesNotPool()
     {
         ArrayByteBufferPool pool = new ArrayByteBufferPool(10, 10, 20, Integer.MAX_VALUE);
+        pool.setStatisticsEnabled(true);
 
         RetainableByteBuffer buf1 = pool.acquire(21, true);
         assertThat(buf1.capacity(), is(21));
@@ -130,6 +133,10 @@ public void testOverMaxCapacityDoesNotPool()
         buf1.release();
         assertThat(pool.getDirectByteBufferCount(), is(0L));
         assertThat(pool.getDirectMemory(), is(0L));
+
+        Map<Integer, Long> noBucketDirectAcquires = pool.getNoBucketDirectAcquires();
+        assertFalse(noBucketDirectAcquires.isEmpty());
+        assertEquals(1L, noBucketDirectAcquires.get(30));
     }
 
     @Test
@@ -165,6 +172,15 @@ public void testRetain()
         assertThat(pool.getAvailableDirectMemory(), is(10L));
         assertThat(pool.getAvailableDirectByteBufferCount(), is(1L));
         assertThat(pool.getDirectByteBufferCount(), is(1L));
+
+        buf1 = pool.acquire(10, true);
+
+        assertThat(pool.getDirectMemory(), is(10L));
+        assertThat(pool.getAvailableDirectMemory(), is(0L));
+        assertThat(pool.getDirectByteBufferCount(), is(1L));
+        assertThat(pool.getAvailableDirectByteBufferCount(), is(0L));
+
+        buf1.release();
     }
 
     @Test