Implement LogbackMetrics binder, ensure Meter deduplication in regist…

…ries

build.gradle

@@ -6,8 +6,6 @@ buildscript {
     dependencies {
         classpath 'org.junit.platform:junit-platform-gradle-plugin:1.0.0-M4'
     }
-
-    configurations.classpath.resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds'
 }
 
 plugins {
@@ -58,12 +56,14 @@ dependencies {
     // cache monitoring
     compile 'com.google.guava:guava:21.0', optional
 
+    // log monitoring
+    compile 'ch.qos.logback:logback-classic:latest.release', optional
+
     // JUnit 5
     testCompile 'org.junit.platform:junit-platform-launcher:1.0.0-M4' // see https://github.com/junit-team/junit5/issues/586 for why this is necessary
     testCompile 'org.junit.jupiter:junit-jupiter-api:5.0.0-M4'
     testCompile 'org.junit.jupiter:junit-jupiter-params:5.0.0-M4'
     testRuntime 'org.junit.jupiter:junit-jupiter-engine:5.0.0-M4'
-    testRuntime 'ch.qos.logback:logback-classic:latest.release'
 
     testCompile 'org.assertj:assertj-core:3.+'
 
@@ -100,10 +100,6 @@ jmh {
     duplicateClassesStrategy = 'warn'
 }
 
-junitPlatform {
-    logManager 'org.apache.logging.log4j.jul.LogManager'
-}
-
 bintray.pkg {
     labels = ['spring', 'metrics', 'prometheus', 'spectator']
 }

src/main/java/org/springframework/metrics/instrument/MeterRegistry.java

@@ -19,16 +19,14 @@
 import org.springframework.metrics.instrument.binder.MeterBinder;
 
 import javax.sql.DataSource;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 import java.util.function.ToDoubleFunction;
 import java.util.stream.Stream;
 
 import static java.util.Collections.emptyList;
 import static java.util.stream.Collectors.toList;
 import static java.util.stream.StreamSupport.stream;
+import static org.springframework.metrics.instrument.Tags.tagList;
 
 /**
  * Creates and manages your application's set of meters. Exporters use the meter registry to iterate
@@ -76,7 +74,7 @@ default Counter counter(String name) {
      * Measures the rate of some activity.
      */
     default Counter counter(String name, String... tags) {
-        return counter(name, toTags(tags));
+        return counter(name, tagList(tags));
     }
 
     /**
@@ -102,7 +100,7 @@ default DistributionSummary distributionSummary(String name) {
      * Measures the sample distribution of events.
      */
     default DistributionSummary distributionSummary(String name, String... tags) {
-        return distributionSummary(name, toTags(tags));
+        return distributionSummary(name, tagList(tags));
     }
 
     /**
@@ -128,7 +126,7 @@ default Timer timer(String name) {
      * Measures the time taken for short tasks.
      */
     default Timer timer(String name, String... tags) {
-        return timer(name, toTags(tags));
+        return timer(name, tagList(tags));
     }
 
     /**
@@ -154,7 +152,7 @@ default LongTaskTimer longTaskTimer(String name) {
      * Measures the time taken for short tasks.
      */
     default LongTaskTimer longTaskTimer(String name, String... tags) {
-        return longTaskTimer(name, toTags(tags));
+        return longTaskTimer(name, tagList(tags));
     }
 
     /**
@@ -303,17 +301,6 @@ default <T extends Collection<?>> T collectionSize(String name, T collection) {
         return mapSize(name, emptyList(), collection);
     }
 
-    default Iterable<Tag> toTags(String... keyValues) {
-        if (keyValues.length % 2 == 1) {
-            throw new IllegalArgumentException("size must be even, it is a set of key=value pairs");
-        }
-        ArrayList<Tag> ts = new ArrayList<>(keyValues.length);
-        for (int i = 0; i < keyValues.length; i += 2) {
-            ts.add(new ImmutableTag(keyValues[i], keyValues[i + 1]));
-        }
-        return ts;
-    }
-
     /**
      * Execute an algorithm to bind one or more metrics to the registry.
      */

src/main/java/org/springframework/metrics/instrument/Tags.java

@@ -0,0 +1,16 @@
+package org.springframework.metrics.instrument;
+
+import java.util.ArrayList;
+
+public class Tags {
+    public static Iterable<Tag> tagList(String... keyValues) {
+        if (keyValues.length % 2 == 1) {
+            throw new IllegalArgumentException("size must be even, it is a set of key=value pairs");
+        }
+        ArrayList<Tag> ts = new ArrayList<>(keyValues.length);
+        for (int i = 0; i < keyValues.length; i += 2) {
+            ts.add(new ImmutableTag(keyValues[i], keyValues[i + 1]));
+        }
+        return ts;
+    }
+}

src/main/java/org/springframework/metrics/instrument/binder/LogbackMetrics.java

@@ -0,0 +1,13 @@
+package org.springframework.metrics.instrument.binder;
+
+import ch.qos.logback.classic.LoggerContext;
+import org.slf4j.LoggerFactory;
+import org.springframework.metrics.instrument.MeterRegistry;
+
+public class LogbackMetrics implements MeterBinder {
+    @Override
+    public void bindTo(MeterRegistry registry) {
+        LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
+        context.addTurboFilter(new MetricsTurboFilter(registry));
+    }
+}

src/main/java/org/springframework/metrics/instrument/binder/MetricsTurboFilter.java

@@ -0,0 +1,34 @@
+package org.springframework.metrics.instrument.binder;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.turbo.TurboFilter;
+import ch.qos.logback.core.spi.FilterReply;
+import org.slf4j.Marker;
+import org.springframework.metrics.instrument.Counter;
+import org.springframework.metrics.instrument.MeterRegistry;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MetricsTurboFilter extends TurboFilter {
+    private final Map<Level, Counter> levelCounters;
+
+    public MetricsTurboFilter(MeterRegistry registry) {
+        levelCounters = new HashMap<Level, Counter>() {{
+            put(Level.ERROR, registry.counter("logback_events", "level", "error"));
+            put(Level.WARN, registry.counter("logback_events", "level", "warn"));
+            put(Level.INFO, registry.counter("logback_events", "level", "info"));
+            put(Level.DEBUG, registry.counter("logback_events", "level", "debug"));
+            put(Level.TRACE, registry.counter("logback_events", "level", "trace"));
+        }};
+    }
+
+    @Override
+    public FilterReply decide(Marker marker, Logger logger, Level level, String format, Object[] params, Throwable t) {
+        Counter counter = levelCounters.get(level);
+        if(counter != null)
+            counter.increment();
+        return FilterReply.ACCEPT;
+    }
+}

src/main/java/org/springframework/metrics/instrument/internal/AbstractMeterRegistry.java

@@ -34,10 +34,11 @@
 import javax.sql.DataSource;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.stream.Stream;
 
 public abstract class AbstractMeterRegistry implements MeterRegistry {
-    private Collection<Meter> meters = new ArrayList<>();
     protected Clock clock;
 
     @Autowired(required = false)
@@ -60,21 +61,11 @@ protected AbstractMeterRegistry(Clock clock) {
         this.clock = clock;
     }
 
-    protected <T extends Meter> T register(T meter) {
-        meters.add(meter);
-        return meter;
-    }
-
     @Override
     public Clock getClock() {
         return clock;
     }
 
-    @Override
-    public Collection<Meter> getMeters() {
-        return meters;
-    }
-
     @Override
     public Cache monitor(String name, Stream<Tag> tags, Cache cache) {
         CacheStats stats = cache.stats();

src/main/java/org/springframework/metrics/instrument/internal/MeterId.java

@@ -0,0 +1,53 @@
+package org.springframework.metrics.instrument.internal;
+
+import org.springframework.metrics.instrument.Tag;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.stream.StreamSupport;
+
+public class MeterId {
+    private final String name;
+    private final Tag[] tags;
+
+    public MeterId(String name, Iterable<Tag> tags) {
+        this.name = name;
+        this.tags = StreamSupport.stream(tags.spliterator(), false).sorted(Comparator.comparing(Tag::getKey))
+                .toArray(Tag[]::new);
+    }
+
+    public static MeterId id(String name, Iterable<Tag> tags) {
+        return new MeterId(name, tags);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        MeterId meterId = (MeterId) o;
+        return (name != null ? name.equals(meterId.name) : meterId.name == null) && Arrays.equals(tags, meterId.tags);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = name != null ? name.hashCode() : 0;
+        result = 31 * result + Arrays.hashCode(tags);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "MeterId{" +
+                "name='" + name + '\'' +
+                ", tags=" + Arrays.toString(tags) +
+                '}';
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Tag[] getTags() {
+        return tags;
+    }
+}

src/main/java/org/springframework/metrics/instrument/prometheus/PrometheusCounter.java

@@ -19,9 +19,9 @@
 
 public class PrometheusCounter implements Counter {
     private final String name;
-    private io.prometheus.client.Gauge.Child counter;
+    private io.prometheus.client.Counter.Child counter;
 
-    public PrometheusCounter(String name, io.prometheus.client.Gauge.Child counter) {
+    public PrometheusCounter(String name, io.prometheus.client.Counter.Child counter) {
         this.name = name;
         this.counter = counter;
     }
@@ -33,10 +33,7 @@ public void increment() {
 
     @Override
     public void increment(double amount) {
-        if (amount < 0)
-            counter.dec(-amount);
-        else
-            counter.inc(amount);
+        counter.inc(amount);
     }
 
     @Override