Add TagReplacingFilter

micrometer-core/src/main/java/io/micrometer/core/instrument/config/MeterFilter.java

@@ -17,6 +17,7 @@
 
 import io.micrometer.common.lang.Nullable;
 import io.micrometer.core.instrument.*;
+import io.micrometer.core.instrument.config.filter.TagReplacingFilter;
 import io.micrometer.core.instrument.distribution.DistributionStatisticConfig;
 
 import java.time.Duration;
@@ -120,22 +121,7 @@ public Meter.Id map(Meter.Id id) {
      * @return A filter that replaces tag values.
      */
     static MeterFilter replaceTagValues(String tagKey, Function<String, String> replacement, String... exceptions) {
-        return new MeterFilter() {
-            @Override
-            public Meter.Id map(Meter.Id id) {
-                List<Tag> tags = stream(id.getTagsAsIterable().spliterator(), false).map(t -> {
-                    if (!t.getKey().equals(tagKey))
-                        return t;
-                    for (String exception : exceptions) {
-                        if (t.getValue().equals(exception))
-                            return t;
-                    }
-                    return Tag.of(tagKey, replacement.apply(t.getValue()));
-                }).collect(toList());
-
-                return id.replaceTags(tags);
-            }
-        };
+        return TagReplacingFilter.classicValueReplacing(tagKey, replacement, exceptions);
     }
 
     /**

micrometer-core/src/main/java/io/micrometer/core/instrument/config/filter/FilterSupport.java

@@ -0,0 +1,31 @@
+/*
+ * 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.config.filter;
+
+class FilterSupport {
+
+    /**
+     * At the moment of writing, it was impossible to estimate tags count from the outside
+     * of class, but quite often a temporary storage (ArrayList) had to be allocated
+     * during processing. To avoid excessive resizes, this constant is introduced to
+     * preallocate space for such a list.
+     */
+    public static final int DEFAULT_TAG_COUNT_EXPECTATION = 32;
+
+    private FilterSupport() {
+    }
+
+}

micrometer-core/src/main/java/io/micrometer/core/instrument/config/filter/NoOpFilter.java

@@ -0,0 +1,37 @@
+/*
+ * 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.config.filter;
+
+import io.micrometer.core.instrument.config.MeterFilter;
+
+/**
+ * A fallback for all factory methods that have received an input functionally equivalent
+ * to "abstain from processing".
+ *
+ * @since 1.15
+ */
+public class NoOpFilter implements MeterFilter {
+
+    private static final MeterFilter INSTANCE = new NoOpFilter();
+
+    private NoOpFilter() {
+    }
+
+    public static MeterFilter create() {
+        return INSTANCE;
+    }
+
+}

micrometer-core/src/main/java/io/micrometer/core/instrument/config/filter/TagReplacingFilter.java

@@ -0,0 +1,130 @@
+/*
+ * 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.config.filter;
+
+import io.micrometer.common.lang.NonNull;
+import io.micrometer.core.instrument.Meter;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.config.MeterFilter;
+
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.BiPredicate;
+import java.util.function.Function;
+
+public class TagReplacingFilter implements MeterFilter {
+
+    private final BiPredicate<String, String> filter;
+
+    private final BiFunction<String, String, Tag> replacer;
+
+    private final int expectedTagCount;
+
+    TagReplacingFilter(BiPredicate<String, String> filter, BiFunction<String, String, Tag> replacer,
+            int expectedTagCount) {
+        this.replacer = replacer;
+        this.filter = filter;
+        this.expectedTagCount = expectedTagCount;
+    }
+
+    @NonNull
+    @Override
+    public Meter.Id map(@NonNull Meter.Id id) {
+        Iterator<Tag> iterator = id.getTagsAsIterable().iterator();
+
+        if (!iterator.hasNext()) {
+            // fast path avoiding list allocation completely
+            return id;
+        }
+
+        List<Tag> replacement = new ArrayList<>(expectedTagCount);
+
+        boolean intercepted = false;
+        while (iterator.hasNext()) {
+            Tag tag = iterator.next();
+            String key = tag.getKey();
+            String value = tag.getValue();
+
+            if (filter.test(key, value)) {
+                replacement.add(replacer.apply(key, value));
+                intercepted = true;
+            }
+            else {
+                replacement.add(tag);
+            }
+        }
+
+        return intercepted ? id.replaceTags(replacement) : id;
+    }
+
+    public static MeterFilter of(BiPredicate<String, String> filter, BiFunction<String, String, Tag> replacer,
+            int expectedSize) {
+        return new TagReplacingFilter(filter, replacer, expectedSize);
+    }
+
+    public static MeterFilter of(BiPredicate<String, String> filter, BiFunction<String, String, Tag> replacer) {
+        return new TagReplacingFilter(filter, replacer, FilterSupport.DEFAULT_TAG_COUNT_EXPECTATION);
+    }
+
+    public static MeterFilter classicValueReplacing(String key, Function<String, String> replacer,
+            Collection<String> exceptions, int expectedSize) {
+        return of(new ClassicFilter(key, new HashSet<>(exceptions)), new ValueReplacer(replacer), expectedSize);
+    }
+
+    public static MeterFilter classicValueReplacing(String key, Function<String, String> replacer,
+            Collection<String> exceptions) {
+        return classicValueReplacing(key, replacer, exceptions, FilterSupport.DEFAULT_TAG_COUNT_EXPECTATION);
+    }
+
+    public static MeterFilter classicValueReplacing(String key, Function<String, String> replacer,
+            String... exceptions) {
+        return classicValueReplacing(key, replacer, Arrays.asList(exceptions));
+    }
+
+    private static class ClassicFilter implements BiPredicate<String, String> {
+
+        private final String matcher;
+
+        private final Set<String> exceptions;
+
+        public ClassicFilter(String matcher, Set<String> exceptions) {
+            this.matcher = matcher;
+            this.exceptions = exceptions;
+        }
+
+        @Override
+        public boolean test(String key, String value) {
+            return key.equals(matcher) && !exceptions.contains(value);
+        }
+
+    }
+
+    private static class ValueReplacer implements BiFunction<String, String, Tag> {
+
+        private final Function<String, String> delegate;
+
+        public ValueReplacer(Function<String, String> delegate) {
+            this.delegate = delegate;
+        }
+
+        @Override
+        public Tag apply(String key, String value) {
+            return Tag.of(key, delegate.apply(value));
+        }
+
+    }
+
+}

micrometer-core/src/main/java/io/micrometer/core/instrument/config/filter/package-info.java

@@ -0,0 +1,16 @@
+/*
+ * 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.config.filter;

micrometer-core/src/test/java/io/micrometer/core/instrument/MeterFilterTest.java → micrometer-core/src/test/java/io/micrometer/core/instrument/config/MeterFilterTest.java

@@ -13,12 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.micrometer.core.instrument;
+package io.micrometer.core.instrument.config;
 
 import io.micrometer.common.lang.Nullable;
 import io.micrometer.core.Issue;
-import io.micrometer.core.instrument.config.MeterFilter;
-import io.micrometer.core.instrument.config.MeterFilterReply;
+import io.micrometer.core.instrument.Meter;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tags;
 import io.micrometer.core.instrument.distribution.DistributionStatisticConfig;
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
 import org.assertj.core.api.Condition;