Add TagReplacingFilter

Signed-off-by: etki <[email protected]>

Author: etki

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

@@ -1,14 +1,16 @@
 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
+     * 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() {}
+    private FilterSupport() {
+    }
+
 }

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

@@ -3,17 +3,20 @@
 import io.micrometer.core.instrument.config.MeterFilter;
 
 /**
- * A fallback for all factory methods that have received an input
- * functionally equivalent to "abstain from processing".
+ * 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() {}
+    private NoOpFilter() {
+    }
 
     public static MeterFilter create() {
         return INSTANCE;
     }
+
 }

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

@@ -0,0 +1,115 @@
+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));
+        }
+
+    }
+
+}