Add wildcard support

Using an asterisk at the configured names ending transforms them
into a prefix that is searched and filtered in the metric names.

Signed-off-by: Karsten Schnitter <k.schnitter@sap.com>

Author: KarstenSchnitter

cf-java-logging-support-opentelemetry-agent-extension/src/main/java/com/sap/hcf/cf/logging/opentelemetry/agent/ext/exporter/FilteringMetricExporter.java

@@ -10,9 +10,12 @@
 import io.opentelemetry.sdk.metrics.export.MetricExporter;
 
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
+
+import static java.util.stream.Collectors.toCollection;
+import static java.util.stream.Collectors.toList;
 
 public class FilteringMetricExporter implements MetricExporter {
 
@@ -29,7 +32,7 @@ private FilteringMetricExporter(MetricExporter delegate, Predicate<MetricData> p
 
     @Override
     public CompletableResultCode export(Collection<MetricData> collection) {
-        List<MetricData> filteredMetrics = collection.stream().filter(predicate).collect(Collectors.toList());
+        List<MetricData> filteredMetrics = collection.stream().filter(predicate).collect(toList());
         return delegate.export(filteredMetrics);
     }
 
@@ -99,13 +102,54 @@ public MetricExporter build() {
             }
 
             Predicate<MetricData> predicate = metricData -> true;
-            if (!includedNames.isEmpty()) {
-                predicate = predicate.and(metricData -> includedNames.contains(metricData.getName()));
+            predicate = addInclusions(predicate, includedNames);
+            predicate = addExclusions(predicate, excludedNames);
+            return new FilteringMetricExporter(delegate, predicate);
+        }
+
+        private static Predicate<MetricData> addInclusions(Predicate<MetricData> predicate,
+                                                           List<String> includedNames) {
+            if (includedNames.isEmpty()) {
+                return predicate;
             }
-            if (!excludedNames.isEmpty()) {
-                predicate = predicate.and(metricData -> !excludedNames.contains(metricData.getName()));
+
+            HashSet<String> names = getNames(includedNames);
+            if (!names.isEmpty()) {
+                predicate = predicate.and(metricData -> names.contains(metricData.getName()));
             }
-            return new FilteringMetricExporter(delegate, predicate);
+            List<String> prefixes = getPrefixes(includedNames);
+            if (!prefixes.isEmpty()) {
+                predicate = predicate.and(
+                        metricData -> prefixes.stream().anyMatch(p -> metricData.getName().startsWith(p)));
+            }
+            return predicate;
+        }
+
+        private static Predicate<MetricData> addExclusions(Predicate<MetricData> predicate,
+                                                           List<String> excludedNames) {
+            if (excludedNames.isEmpty()) {
+                return predicate;
+            }
+
+            HashSet<String> names = getNames(excludedNames);
+            if (!names.isEmpty()) {
+                predicate = predicate.and(metricData -> !names.contains(metricData.getName()));
+            }
+            List<String> prefixes = getPrefixes(excludedNames);
+            if (!prefixes.isEmpty()) {
+                predicate = predicate.and(
+                        metricData -> prefixes.stream().anyMatch(p -> !metricData.getName().startsWith(p)));
+            }
+            return predicate;
+        }
+
+        private static HashSet<String> getNames(List<String> names) {
+            return names.stream().filter(n -> !n.endsWith("*")).collect(toCollection(HashSet::new));
+        }
+
+        private static List<String> getPrefixes(List<String> names) {
+            return names.stream().filter(n -> n.endsWith("*")).map(n -> n.substring(0, n.length() - 1))
+                        .collect(toList());
         }
     }
 }

cf-java-logging-support-opentelemetry-agent-extension/src/test/java/com/sap/hcf/cf/logging/opentelemetry/agent/ext/exporter/FilteringMetricExporterTest.java

@@ -103,6 +103,38 @@ void rejectsExcludedFromIncluded() {
         assertThat(exported.getValue()).containsExactlyInAnyOrder(includedMetric);
     }
 
+    @Test
+    void supportsWildcardsOnIncluded() {
+        ConfigProperties config = createConfig(MapEntry.entry("include.names", "incl*"));
+        try (MetricExporter exporter = FilteringMetricExporter.wrap(delegate).withConfig(config).build()) {
+            exporter.export(asList(includedMetric, excludedMetric, anotherMetric));
+        }
+        verify(delegate).export(exported.capture());
+        assertThat(exported.getValue()).containsExactlyInAnyOrder(includedMetric);
+    }
+
+    @Test
+    void supportsWildcardsOnEncluded() {
+        ConfigProperties config = createConfig(MapEntry.entry("exclude.names", "excl*"));
+        try (MetricExporter exporter = FilteringMetricExporter.wrap(delegate).withConfig(config).build()) {
+            exporter.export(asList(includedMetric, excludedMetric, anotherMetric));
+        }
+        verify(delegate).export(exported.capture());
+        assertThat(exported.getValue()).containsExactlyInAnyOrder(includedMetric, anotherMetric);
+    }
+
+    @Test
+    void supportsConfigPrefixes() {
+        ConfigProperties config = createConfig(MapEntry.entry("config.include.names", "included,excluded"),
+                                               MapEntry.entry("config.exclude.names", "excluded"));
+        try (MetricExporter exporter = FilteringMetricExporter.wrap(delegate).withConfig(config)
+                                                              .withPropertyPrefix("config").build()) {
+            exporter.export(asList(includedMetric, excludedMetric, anotherMetric));
+        }
+        verify(delegate).export(exported.capture());
+        assertThat(exported.getValue()).containsExactlyInAnyOrder(includedMetric);
+    }
+
     @SafeVarargs
     private static ConfigProperties createConfig(MapEntry<String, String>... entries) {
         HashMap<String, String> map = new HashMap<>();