Add allocation tests

Author: shakuzen

micrometer-core/src/main/java/io/micrometer/core/instrument/MeterRegistry.java

@@ -456,7 +456,7 @@ public RequiredSearch get(String name) {
      * @return A new or existing counter.
      */
     public Counter counter(String name, Iterable<Tag> tags) {
-        return Counter.builder(name).tags(tags).register(this);
+        return counter(name, Tags.of(tags));
     }
 
     /**
@@ -470,6 +470,17 @@ public Counter counter(String name, String... tags) {
         return counter(name, Tags.of(tags));
     }
 
+    /**
+     * Tracks a monotonically increasing value.
+     * @param name The base metric name
+     * @param tags Sequence of dimensions for breaking down the name.
+     * @return A new or existing counter.
+     * @since 1.16.0
+     */
+    public Counter counter(String name, Tags tags) {
+        return counter(new Meter.Id(name, tags, null, null, Meter.Type.COUNTER));
+    }
+
     /**
      * Measures the distribution of samples.
      * @param name The base metric name
@@ -498,8 +509,7 @@ public DistributionSummary summary(String name, String... tags) {
      * @return A new or existing timer.
      */
     public Timer timer(String name, Iterable<Tag> tags) {
-        return this.timer(new Meter.Id(name, Tags.of(tags), null, null, Meter.Type.TIMER),
-                AbstractTimerBuilder.DEFAULT_DISTRIBUTION_CONFIG, pauseDetector);
+        return this.timer(name, Tags.of(tags));
     }
 
     /**
@@ -513,6 +523,18 @@ public Timer timer(String name, String... tags) {
         return timer(name, Tags.of(tags));
     }
 
+    /**
+     * Measures the time taken for short tasks and the count of these tasks.
+     * @param name The base metric name
+     * @param tags Sequence of dimensions for breaking down the name.
+     * @return A new or existing timer.
+     * @since 1.16.0
+     */
+    public Timer timer(String name, Tags tags) {
+        return this.timer(new Meter.Id(name, tags, null, null, Meter.Type.TIMER),
+                AbstractTimerBuilder.DEFAULT_DISTRIBUTION_CONFIG, pauseDetector);
+    }
+
     /**
      * Access to less frequently used meter types and patterns.
      * @return Access to additional meter types and patterns.
@@ -1093,7 +1115,18 @@ public LongTaskTimer longTaskTimer(String name, String... tags) {
          * @return A new or existing long task timer.
          */
         public LongTaskTimer longTaskTimer(String name, Iterable<Tag> tags) {
-            return longTaskTimer(new Meter.Id(name, Tags.of(tags), null, null, Meter.Type.LONG_TASK_TIMER),
+            return longTaskTimer(name, Tags.of(tags));
+        }
+
+        /**
+         * Measures the time taken for long tasks.
+         * @param name Name of the long task timer being registered.
+         * @param tags Sequence of dimensions for breaking down the name.
+         * @return A new or existing long task timer.
+         * @since 1.16.0
+         */
+        public LongTaskTimer longTaskTimer(String name, Tags tags) {
+            return longTaskTimer(new Meter.Id(name, tags, null, null, Meter.Type.LONG_TASK_TIMER),
                     LongTaskTimer.Builder.DEFAULT_DISTRIBUTION_CONFIG);
         }
 

micrometer-core/src/test/java/io/micrometer/core/instrument/MeterRegistryAllocationTest.java

@@ -0,0 +1,141 @@
+/*
+ * Copyright 2025 VMware, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.micrometer.core.instrument;
+
+import com.sun.management.ThreadMXBean;
+import io.micrometer.core.Issue;
+import io.micrometer.core.instrument.distribution.pause.NoPauseDetector;
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.condition.DisabledIfSystemProperty;
+
+import java.lang.management.ManagementFactory;
+
+import static io.micrometer.core.instrument.MeterRegistryAllocationTest.JAVA_VM_NAME_J9_REGEX;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests expected allocation (or lack thereof) for methods expected to be used on hot
+ * paths from {@link MeterRegistry}.
+ */
+@DisabledIfSystemProperty(named = "java.vm.name", matches = JAVA_VM_NAME_J9_REGEX,
+        disabledReason = "Sun ThreadMXBean with allocation counter not available")
+class MeterRegistryAllocationTest {
+
+    // Should match "Eclipse OpenJ9 VM" and "IBM J9 VM"
+    static final String JAVA_VM_NAME_J9_REGEX = ".*J9 VM$";
+
+    MeterRegistry registry = new SimpleMeterRegistry();
+
+    Tags tags = Tags.of("a", "b", "c", "d");
+
+    static ThreadMXBean threadMXBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
+
+    /**
+     * Number of bytes allocated when constructing a Meter.Id. This can vary by JVM and
+     * configuration, which is why we measure it programmatically. For most common cases,
+     * it should be 40 bytes.
+     */
+    static long newIdBytes;
+
+    @BeforeAll
+    static void setup() {
+        // Construct once here so any static initialization doesn't get measured.
+        new Meter.Id("name", Tags.empty(), null, null, Meter.Type.OTHER);
+        newIdBytes = measureAllocatedBytes(() -> new Meter.Id("name", Tags.empty(), null, null, Meter.Type.OTHER));
+    }
+
+    private static long measureAllocatedBytes(Runnable runnable) {
+        long currentThreadId = Thread.currentThread().getId();
+        long allocatedBytesBefore = threadMXBean.getThreadAllocatedBytes(currentThreadId);
+
+        runnable.run();
+
+        return threadMXBean.getThreadAllocatedBytes(currentThreadId) - allocatedBytesBefore;
+    }
+
+    @BeforeEach
+    void setUp() {
+        registry.timer("timer", tags);
+        LongTaskTimer.builder("ltt").tags(tags).register(registry);
+        Counter.builder("counter").tags(tags).register(registry);
+    }
+
+    @Nested
+    @DisplayName("Internal implementation details")
+    class Internal {
+
+        @Issue("#6670")
+        @Test
+        void retrieveExistingTimer_noAllocation() {
+            Meter.Id id = new Meter.Id("timer", tags, null, null, Meter.Type.TIMER);
+            // test allocation from internal implementation (non-public API)
+            assertNoAllocation(() -> registry.timer(id, AbstractTimerBuilder.DEFAULT_DISTRIBUTION_CONFIG,
+                    NoPauseDetector.INSTANCE));
+        }
+
+        @Issue("#6670")
+        @Test
+        void retrieveExistingLongTaskTimer_noAllocation() {
+            Meter.Id id = new Meter.Id("ltt", tags, null, null, Meter.Type.LONG_TASK_TIMER);
+            // test allocation from internal implementation (non-public API)
+            assertNoAllocation(
+                    () -> registry.more().longTaskTimer(id, LongTaskTimer.Builder.DEFAULT_DISTRIBUTION_CONFIG));
+        }
+
+        @Issue("#6670")
+        @Test
+        void retrieveExistingCounter_noAllocation() {
+            Meter.Id id = new Meter.Id("counter", tags, null, null, Meter.Type.COUNTER);
+            // test allocation from internal implementation (non-public API)
+            assertNoAllocation(() -> registry.counter(id));
+        }
+
+    }
+
+    @Nested
+    @DisplayName("Public API available to users")
+    class PublicApi {
+
+        @Issue("#6670")
+        @Test
+        void retrieveExistingTimer_onlyIdAllocation() {
+            assertBytesAllocated(newIdBytes, () -> registry.timer("timer", tags));
+        }
+
+        @Issue("#6670")
+        @Test
+        void retrieveExistingLongTaskTimer_onlyIdAllocation() {
+            assertBytesAllocated(newIdBytes, () -> registry.more().longTaskTimer("ltt", tags));
+        }
+
+        @Issue("#6670")
+        @Test
+        void retrieveExistingCounter_onlyIdAllocation() {
+            assertBytesAllocated(newIdBytes, () -> registry.counter("counter", tags));
+        }
+
+    }
+
+    private void assertBytesAllocated(long bytes, Runnable runnable) {
+        assertThat(measureAllocatedBytes(runnable)).isEqualTo(bytes);
+    }
+
+    private void assertNoAllocation(Runnable runnable) {
+        assertBytesAllocated(0, runnable);
+    }
+
+}