Improve Prometheus output performance (helidon-io#10850)

tjquinno · barchetta · commit 5ba3c39638cf · 2025-11-24T12:48:15.000-08:00
diff --git a/metrics/providers/micrometer/src/main/java/io/helidon/metrics/providers/micrometer/MicrometerPrometheusFormatter.java b/metrics/providers/micrometer/src/main/java/io/helidon/metrics/providers/micrometer/MicrometerPrometheusFormatter.java
@@ -20,7 +20,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
-import java.util.function.Predicate;
+import java.util.regex.Pattern;
 
 import io.helidon.common.media.type.MediaType;
 import io.helidon.common.media.type.MediaTypes;
@@ -49,16 +49,34 @@ public class MicrometerPrometheusFormatter implements MeterRegistryFormatter {
     public static final Map<MediaType, String> MEDIA_TYPE_TO_FORMAT = Map.of(
             MediaTypes.TEXT_PLAIN, TextFormat.CONTENT_TYPE_004,
             MediaTypes.APPLICATION_OPENMETRICS_TEXT, TextFormat.CONTENT_TYPE_OPENMETRICS_100);
+
+    private static final Pattern SPECIAL_CHARACTERS_MAPPED_TO_UNDERSCORE_PATTERN = Pattern.compile("[-+.!?@#$%^&*`'\\s]+");
+    private static final Pattern NON_DIGIT_OR_UNDERSCORE_PREFIX_PATTERN = Pattern.compile("^[0-9_]+.*");
+    private static final Pattern NON_IDENTIFIER_PATTERN = Pattern.compile("[^A-Za-z0-9_:]");
+
     private final String scopeTagName;
-    private final Iterable<String> scopeSelection;
-    private final Iterable<String> meterNameSelection;
+    private final Set<String> scopes;
+    private final Set<String> meterNames;
     private final MediaType resultMediaType;
     private final MeterRegistry meterRegistry;
 
     private MicrometerPrometheusFormatter(Builder builder) {
         scopeTagName = builder.scopeTagName;
-        scopeSelection = builder.scopeSelection;
-        meterNameSelection = builder.meterNameSelection;
+        meterNames = (builder.meterNameSelection instanceof Set<String> namesSet)
+                ? namesSet
+                : new HashSet<>() {
+                    {
+                        builder.meterNameSelection.forEach(this::add);
+                    }
+                };
+
+        scopes = (builder.scopeSelection instanceof Set<String> scopesSet)
+                ? scopesSet
+                : new HashSet<>() {
+                    {
+                        builder.scopeSelection.forEach(this::add);
+                    }
+                };
         resultMediaType = builder.resultMediaType;
         meterRegistry = Objects.requireNonNullElseGet(builder.meterRegistry,
                                                       io.helidon.metrics.api.Metrics::globalRegistry);
@@ -84,15 +102,15 @@ public static String normalizeNameToPrometheus(String name) {
         String result = name;
 
         // Convert special characters to underscores.
-        result = result.replaceAll("[-+.!?@#$%^&*`'\\s]+", "_");
+        result = SPECIAL_CHARACTERS_MAPPED_TO_UNDERSCORE_PATTERN.matcher(result).replaceAll("_");
 
         // Prometheus simple client adds the prefix "m_" if a meter name starts with a digit or an underscore.
-        if (result.matches("^[0-9_]+.*")) {
+        if (NON_DIGIT_OR_UNDERSCORE_PREFIX_PATTERN.matcher(result).matches()) {
             result = "m_" + result;
         }
 
         // Replace non-identifier characters.
-        result = result.replaceAll("[^A-Za-z0-9_:]", "_");
+        result = NON_IDENTIFIER_PATTERN.matcher(result).replaceAll("_");
 
         return result;
     }
@@ -123,17 +141,24 @@ public Optional<Object> format() {
         Optional<PrometheusMeterRegistry> prometheusMeterRegistry = prometheusMeterRegistry(meterRegistry);
         if (prometheusMeterRegistry.isPresent()) {
 
-            // Scraping the Prometheus registry lets us limit the output to include only specified names.
-            Set<String> meterNamesOfInterest = meterNamesOfInterest(prometheusMeterRegistry.get(),
-                                                                    scopeSelection,
-                                                                    meterNameSelection);
-            if (meterNamesOfInterest.isEmpty()) {
-                return Optional.empty();
+            /*
+            Optimize for the no-selection case (neither scope nor name selections were requested).
+             */
+            Set<String> meterNamesOfInterest;
+
+            if (meterNames.isEmpty() && scopes.isEmpty()) {
+                meterNamesOfInterest = null; // The Prometheus registry's scrape method treats null as "match all names."
+            } else {
+                meterNamesOfInterest = meterNamesOfInterest(prometheusMeterRegistry.get(),
+                                     scopes,
+                                     meterNames);
+                if (meterNamesOfInterest.isEmpty()) {
+                    return Optional.empty();
+                }
             }
 
             String prometheusOutput = prometheusMeterRegistry.get()
-                    .scrape(MicrometerPrometheusFormatter.MEDIA_TYPE_TO_FORMAT.get(
-                                    resultMediaType),
+                    .scrape(MicrometerPrometheusFormatter.MEDIA_TYPE_TO_FORMAT.get(resultMediaType),
                             meterNamesOfInterest);
 
             return prometheusOutput.isBlank() ? Optional.empty() : Optional.of(prometheusOutput);
@@ -166,31 +191,23 @@ public Optional<Object> formatMetadata() {
      * </p>
      *
      * @param prometheusMeterRegistry Prometheus meter registry to query
-     * @param scopeSelection          scope names to select
-     * @param meterNameSelection      meter names to select
+     * @param scopes          scope names to select
+     * @param names           meter names to select
      * @return set of matching meter names (with units and suffixes as needed) to match the names as stored in the meter registry
      */
     Set<String> meterNamesOfInterest(PrometheusMeterRegistry prometheusMeterRegistry,
-                                     Iterable<String> scopeSelection,
-                                     Iterable<String> meterNameSelection) {
+                                     Set<String> scopes,
+                                     Set<String> names) {
 
         Set<String> result = new HashSet<>();
 
-        var scopes = new HashSet<>();
-        scopeSelection.forEach(scopes::add);
-
-        var names = new HashSet<>();
-        meterNameSelection.forEach(names::add);
-
-        Predicate<Meter> scopePredicate = scopes.isEmpty() || scopeTagName == null || scopeTagName.isBlank()
-                ? m -> true
-                : m -> scopes.contains(m.getId().getTag(scopeTagName));
-
-        Predicate<String> namePredicate = names.isEmpty() ? n -> true : names::contains;
-
         for (Meter meter : prometheusMeterRegistry.getMeters()) {
             String meterName = meter.getId().getName();
-            if (!namePredicate.test(meterName) || !scopePredicate.test(meter)) {
+            if ((!names.isEmpty() && !names.contains(meterName))
+                || (!scopes.isEmpty()
+                            && scopeTagName != null
+                            && !scopeTagName.isBlank()
+                            && !scopes.contains(meter.getId().getTag(scopeTagName)))) {
                 continue;
             }
             Set<String> allUnitsForMeterName = new HashSet<>();
diff --git a/metrics/providers/micrometer/src/test/java/io/helidon/metrics/providers/micrometer/TestPrometheusFormatting.java b/metrics/providers/micrometer/src/test/java/io/helidon/metrics/providers/micrometer/TestPrometheusFormatting.java
@@ -238,6 +238,92 @@ void testMeterNameWithColon() {
                          endsWith(OPENMETRICS_EOF)));
     }
 
+    @Test
+    void testMeterNameWithSpecialChars() {
+        Counter counterWithDashes = meterRegistry.getOrCreate(Counter.builder("counter-with-dashes"));
+        counterWithDashes.increment(3L);
+
+        Counter counterWithUmlauts = meterRegistry.getOrCreate(Counter.builder("counter-with-umlaut-äöü"));
+        counterWithUmlauts.increment(4L);
+        var formatter =  MicrometerPrometheusFormatter.builder(meterRegistry)
+                .resultMediaType(MediaTypes.APPLICATION_OPENMETRICS_TEXT)
+                .scopeTagName(SCOPE_TAG_NAME)
+                .build();
+
+        Optional<Object> output = formatter.format();
+        assertThat("With dashes",
+                   checkAndCast(output),
+                   allOf(
+                       containsString(scopeExpr("counter_with_dashes_total",
+                                                "this_scope",
+                                                "app",
+                                                "3.0")),
+                       containsString(scopeExpr("counter_with_umlaut_____total",
+                                                "this_scope",
+                                                "app",
+                                                "4.0"))));
+
+
+    }
+
+    @Test
+    void testSelectiveByName() {
+        Counter counter = meterRegistry.getOrCreate(Counter.builder("counterByName"));
+        counter.increment();
+
+        var formatter =  MicrometerPrometheusFormatter.builder(meterRegistry)
+                .resultMediaType(MediaTypes.APPLICATION_OPENMETRICS_TEXT)
+                .meterNameSelection(Set.of("counterByName"))
+                .scopeTagName(SCOPE_TAG_NAME)
+                .build();
+
+        Optional<Object> output = formatter.format();
+        assertThat("Selective by name",
+                   checkAndCast(output),
+                   containsString(scopeExpr("counterByName_total",
+                                            "this_scope",
+                                            "app",
+                                            "1.0")));
+    }
+
+    @Test
+    void testSelectiveByNameAndScope() {
+        Counter counter = meterRegistry.getOrCreate(Counter.builder("counterByNameAndScope"));
+        counter.increment(6L);
+
+        var formatter =  MicrometerPrometheusFormatter.builder(meterRegistry)
+                .resultMediaType(MediaTypes.APPLICATION_OPENMETRICS_TEXT)
+                .meterNameSelection(Set.of("counterByNameAndScope"))
+                .scopeSelection(Set.of("app"))
+                .scopeTagName(SCOPE_TAG_NAME)
+                .build();
+
+        Optional<Object> output = formatter.format();
+        assertThat("Selective by name and scope",
+                   checkAndCast(output),
+                   containsString(scopeExpr("counterByNameAndScope_total",
+                                            "this_scope",
+                                            "app",
+                                            "6.0")));
+    }
+
+    @Test
+    void testSelectNonExistentScope() {
+        Counter counter = meterRegistry.getOrCreate(Counter.builder("counterByBadScope"));
+        counter.increment(7L);
+
+        var formatter =  MicrometerPrometheusFormatter.builder(meterRegistry)
+                .resultMediaType(MediaTypes.APPLICATION_OPENMETRICS_TEXT)
+                .scopeSelection(Set.of("missing"))
+                .scopeTagName(SCOPE_TAG_NAME)
+                .build();
+
+        Optional<Object> output = formatter.format();
+        assertThat("Selective by non-existent scope",
+                   output,
+                   OptionalMatcher.optionalEmpty());
+    }
+
     private static String scopeExpr(String meterName, String key, String value, String suffix) {
         return meterName + "{" + key + "=\"" + value + "\"} " + suffix;
     }
diff --git a/metrics/providers/micrometer/src/test/java/io/helidon/metrics/providers/micrometer/TestPrometheusPerf.java b/metrics/providers/micrometer/src/test/java/io/helidon/metrics/providers/micrometer/TestPrometheusPerf.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2025 Oracle and/or its affiliates.
+ *
+ * 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
+ *
+ *     http://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.helidon.metrics.providers.micrometer;
+
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
+import io.helidon.common.media.type.MediaTypes;
+import io.helidon.metrics.api.Counter;
+import io.helidon.metrics.api.DistributionSummary;
+import io.helidon.metrics.api.MeterRegistry;
+import io.helidon.metrics.api.Metrics;
+import io.helidon.metrics.api.Timer;
+
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Retained for ad hoc simple performance testing of Prometheus formatting. To get a rough timing, uncomment the @Disabled
+ * annotation below, run the test, and look in the test's output file in target/surefire to see the timings.
+ * This test does not attempt to detect any failure condition; it simply runs the code to capture timing.
+ */
+class TestPrometheusPerf {
+
+    @Disabled
+    @Test
+    void testPerf() {
+        int loops = 40;
+
+        // Warmup
+        registerAndFormat(10);
+
+        // Timed test
+        double[] results = registerAndFormat(loops);
+
+        double totalElapsedMillis = 0.0;
+        for (double result : results) {
+            totalElapsedMillis += result;
+        }
+
+        System.err.println("Durations:" + Arrays.toString(results));
+        System.err.println("Mean: " + totalElapsedMillis / (double) loops);
+    }
+
+    private static double[] registerAndFormat(int loops) {
+
+        double[] result = new double[loops];
+
+        for (int loop = 0; loop < loops; loop++) {
+            MeterRegistry meterRegistry = Metrics.globalRegistry();
+            meterRegistry.close();
+
+            Random random = new Random();
+            for (int i = 0; i < 400; i++) {
+                Counter c = meterRegistry.getOrCreate(Counter.builder("ctr" + i));
+                c.increment();
+
+                Timer t = meterRegistry.getOrCreate(Timer.builder("tmr" + i));
+                t.record(123, TimeUnit.MILLISECONDS);
+
+                DistributionSummary ds = meterRegistry.getOrCreate(DistributionSummary.builder("dist" + i));
+                ds.record(random.nextDouble());
+            }
+
+            long start = System.nanoTime();
+            MicrometerPrometheusFormatter formatter = MicrometerPrometheusFormatter.builder(meterRegistry)
+                    .resultMediaType(MediaTypes.APPLICATION_OPENMETRICS_TEXT)
+                    .build();
+            Optional<Object> outputOpt = formatter.format();
+            result[loop] = (System.nanoTime() - start) / 1000.0 / 1000.0;
+            meterRegistry.close();
+            System.err.println(outputOpt.toString());
+        }
+
+        return result;
+    }
+}
