Micrometer metrics

bundle/pom.xml

@@ -37,6 +37,10 @@
       <artifactId>slf4j-api</artifactId>
       <optional>true</optional>
     </dependency>
+    <dependency>
+      <groupId>io.micrometer</groupId>
+      <artifactId>micrometer-core</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.graalvm.nativeimage</groupId>
       <artifactId>svm</artifactId>

driver/pom.xml

@@ -37,6 +37,10 @@
     </dependency>
 
     <!-- Optional and / or provided dependencies -->
+    <dependency>
+      <groupId>io.micrometer</groupId>
+      <artifactId>micrometer-core</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>

driver/src/main/java/org/neo4j/driver/Config.java

@@ -22,6 +22,7 @@
 import java.io.Serializable;
 import java.net.InetAddress;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 
@@ -30,8 +31,11 @@
 import org.neo4j.driver.internal.async.pool.PoolSettings;
 import org.neo4j.driver.internal.cluster.RoutingSettings;
 import org.neo4j.driver.internal.handlers.pulln.FetchSizeUtil;
+import org.neo4j.driver.internal.metrics.MetricsProvider;
+import org.neo4j.driver.internal.metrics.MicrometerMetricsProvider;
 import org.neo4j.driver.internal.retry.RetrySettings;
 import org.neo4j.driver.net.ServerAddressResolver;
+import org.neo4j.driver.util.Experimental;
 import org.neo4j.driver.util.Immutable;
 
 import static java.lang.String.format;
@@ -92,9 +96,9 @@ public class Config implements Serializable
     private final RetrySettings retrySettings;
     private final ServerAddressResolver resolver;
 
-    private final boolean isMetricsEnabled;
     private final int eventLoopThreads;
     private final String userAgent;
+    private final MetricsAdapter metricsAdapter;
 
     private Config( ConfigBuilder builder )
     {
@@ -118,7 +122,7 @@ private Config( ConfigBuilder builder )
         this.fetchSize = builder.fetchSize;
 
         this.eventLoopThreads = builder.eventLoopThreads;
-        this.isMetricsEnabled = builder.isMetricsEnabled;
+        this.metricsAdapter = builder.metricsAdapter;
     }
 
     /**
@@ -256,7 +260,12 @@ public int eventLoopThreads()
      */
     public boolean isMetricsEnabled()
     {
-        return isMetricsEnabled;
+        return this.metricsAdapter != MetricsAdapter.DEV_NULL;
+    }
+
+    public MetricsAdapter metricsAdapter()
+    {
+        return this.metricsAdapter;
     }
 
     /**
@@ -286,7 +295,7 @@ public static class ConfigBuilder
         private int connectionTimeoutMillis = (int) TimeUnit.SECONDS.toMillis( 30 );
         private RetrySettings retrySettings = RetrySettings.DEFAULT;
         private ServerAddressResolver resolver;
-        private boolean isMetricsEnabled = false;
+        private MetricsAdapter metricsAdapter = MetricsAdapter.DEV_NULL;
         private long fetchSize = FetchSizeUtil.DEFAULT_FETCH_SIZE;
         private int eventLoopThreads = 0;
 
@@ -699,13 +708,13 @@ public ConfigBuilder withResolver( ServerAddressResolver resolver )
         }
 
         /**
-         * Enable driver metrics. The metrics can be obtained afterwards via {@link Driver#metrics()}.
+         * Enable driver metrics backed by internal basic implementation. The metrics can be obtained afterwards via {@link Driver#metrics()}.
+         *
          * @return this builder.
          */
         public ConfigBuilder withDriverMetrics()
         {
-            this.isMetricsEnabled = true;
-            return this;
+            return withMetricsEnabled( true );
         }
 
         /**
@@ -714,7 +723,37 @@ public ConfigBuilder withDriverMetrics()
          */
         public ConfigBuilder withoutDriverMetrics()
         {
-            this.isMetricsEnabled = false;
+            return withMetricsEnabled( false );
+        }
+
+        private ConfigBuilder withMetricsEnabled( boolean enabled )
+        {
+            if ( !enabled )
+            {
+                this.metricsAdapter = MetricsAdapter.DEV_NULL;
+            }
+            else if ( this.metricsAdapter == null || this.metricsAdapter == MetricsAdapter.DEV_NULL )
+            {
+                this.metricsAdapter = MetricsAdapter.DEFAULT;
+            }
+            return this;
+        }
+
+        /**
+         * Enable driver metrics backed by a different metrics provider.
+         * <p>
+         * We offer an implementation based on <a href="https://micrometer.io">Micrometer</a>.
+         * The metrics can be obtained afterwards via Micrometer means and {@link Driver#metrics()}.
+         * You must have Micrometer on classpath to use the provided {@link MicrometerMetricsProvider}.
+         * <p>
+         *
+         * @param metricsAdapter the metrics adapter to use. Use {@link MetricsAdapter#DEV_NULL} to disable metrics again.
+         * @return this builder.
+         */
+        @Experimental
+        public ConfigBuilder withMetricsAdapter( MetricsAdapter metricsAdapter )
+        {
+            this.metricsAdapter = Objects.requireNonNull( metricsAdapter, "metricsAdapter" );
             return this;
         }
 

driver/src/main/java/org/neo4j/driver/ConnectionPoolMetrics.java

@@ -30,8 +30,9 @@
 public interface ConnectionPoolMetrics
 {
     /**
-     * An unique id that identifies this pool metrics.
-     * @return An unique name
+     * A unique id that identifies this pool metrics.
+     *
+     * @return A unique name
      */
     String id();
 
@@ -59,7 +60,7 @@ public interface ConnectionPoolMetrics
     /**
      * A counter to record how many connections have been successfully created with this pool since the pool is created.
      * This number increases every time when a connection is successfully created.
-     * @return The amount of connections have ever been created by this pool.
+     * @return The amount of connections has ever been created by this pool.
      */
     long created();
 

driver/src/main/java/org/neo4j/driver/Driver.java

@@ -148,19 +148,17 @@ public interface Driver extends AutoCloseable
 
     /**
      * Returns the driver metrics if metrics reporting is enabled via {@link Config.ConfigBuilder#withDriverMetrics()}.
-     * Otherwise a {@link ClientException} will be thrown.
+     * Otherwise, a {@link ClientException} will be thrown.
      * @return the driver metrics if enabled.
      * @throws ClientException if the driver metrics reporting is not enabled.
      */
-    @Experimental
     Metrics metrics();
 
     /**
      * Returns true if the driver metrics reporting is enabled via {@link Config.ConfigBuilder#withDriverMetrics()}, otherwise false.
      *
      * @return true if the metrics reporting is enabled.
      */
-    @Experimental
     boolean isMetricsEnabled();
 
     /**

driver/src/main/java/org/neo4j/driver/MetricsAdapter.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * 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 org.neo4j.driver;
+
+/**
+ * Defines which metrics consumer to use: Should metrics be consumed and exposed via the drivers default consumer or
+ * provided with one of the external facades.
+ */
+public enum MetricsAdapter
+{
+    /**
+     * Disables metrics.
+     */
+    DEV_NULL,
+
+    /**
+     * Consumes and publishes metrics via the driver itself.
+     */
+    DEFAULT,
+
+    /**
+     * Consumes and publishes metrics via Micrometer. Make sure you put Micrometer on the classpath before using this option.
+     */
+    MICROMETER
+}

driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java

@@ -31,6 +31,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Logger;
 import org.neo4j.driver.Logging;
+import org.neo4j.driver.MetricsAdapter;
 import org.neo4j.driver.internal.async.connection.BootstrapFactory;
 import org.neo4j.driver.internal.async.connection.ChannelConnector;
 import org.neo4j.driver.internal.async.connection.ChannelConnectorImpl;
@@ -42,8 +43,10 @@
 import org.neo4j.driver.internal.cluster.loadbalancing.LoadBalancer;
 import org.neo4j.driver.internal.cluster.loadbalancing.LoadBalancingStrategy;
 import org.neo4j.driver.internal.logging.NettyLogging;
+import org.neo4j.driver.internal.metrics.DevNullMetricsProvider;
 import org.neo4j.driver.internal.metrics.InternalMetricsProvider;
 import org.neo4j.driver.internal.metrics.MetricsProvider;
+import org.neo4j.driver.internal.metrics.MicrometerMetricsProvider;
 import org.neo4j.driver.internal.retry.ExponentialBackoffRetryLogic;
 import org.neo4j.driver.internal.retry.RetryLogic;
 import org.neo4j.driver.internal.retry.RetrySettings;
@@ -56,7 +59,6 @@
 
 import static org.neo4j.driver.internal.Scheme.isRoutingScheme;
 import static org.neo4j.driver.internal.cluster.IdentityResolver.IDENTITY_RESOLVER;
-import static org.neo4j.driver.internal.metrics.MetricsProvider.METRICS_DISABLED_PROVIDER;
 import static org.neo4j.driver.internal.util.ErrorUtil.addSuppressed;
 
 public class DriverFactory
@@ -94,7 +96,7 @@ public final Driver newInstance( URI uri, AuthToken authToken, RoutingSettings r
         EventExecutorGroup eventExecutorGroup = bootstrap.config().group();
         RetryLogic retryLogic = createRetryLogic( retrySettings, eventExecutorGroup, config.logging() );
 
-        MetricsProvider metricsProvider = createDriverMetrics( config, createClock() );
+        MetricsProvider metricsProvider = getOrCreateMetricsProvider( config, createClock() );
         ConnectionPool connectionPool = createConnectionPool( authToken, securityPlan, bootstrap, metricsProvider, config,
                                                               ownsEventLoopGroup, newRoutingSettings.routingContext() );
 
@@ -114,16 +116,24 @@ protected ConnectionPool createConnectionPool( AuthToken authToken, SecurityPlan
         return new ConnectionPoolImpl( connector, bootstrap, poolSettings, metricsProvider.metricsListener(), config.logging(), clock, ownsEventLoopGroup );
     }
 
-    protected static MetricsProvider createDriverMetrics( Config config, Clock clock )
+    protected static MetricsProvider getOrCreateMetricsProvider( Config config, Clock clock )
     {
-        if( config.isMetricsEnabled() )
+        MetricsAdapter metricsAdapter = config.metricsAdapter();
+        // This can actually only happen when someone mocks the config
+        if ( metricsAdapter == null )
         {
-            return new InternalMetricsProvider( clock, config.logging() );
+            metricsAdapter = config.isMetricsEnabled() ? MetricsAdapter.DEFAULT : MetricsAdapter.DEV_NULL;
         }
-        else
+        switch ( metricsAdapter )
         {
-            return METRICS_DISABLED_PROVIDER;
+        case DEV_NULL:
+            return DevNullMetricsProvider.INSTANCE;
+        case DEFAULT:
+            return new InternalMetricsProvider( clock, config.logging() );
+        case MICROMETER:
+            return MicrometerMetricsProvider.forGlobalRegistry();
         }
+        throw new IllegalStateException( "Unknown or unsupported MetricsAdapter: " + metricsAdapter );
     }
 
     protected ChannelConnector createConnector( ConnectionSettings settings, SecurityPlan securityPlan,

driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java

@@ -25,12 +25,13 @@
 import org.neo4j.driver.Logger;
 import org.neo4j.driver.Logging;
 import org.neo4j.driver.Metrics;
+import org.neo4j.driver.internal.metrics.MetricsProvider;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.SessionConfig;
 import org.neo4j.driver.async.AsyncSession;
 import org.neo4j.driver.internal.async.InternalAsyncSession;
 import org.neo4j.driver.internal.async.NetworkSession;
-import org.neo4j.driver.internal.metrics.MetricsProvider;
+import org.neo4j.driver.internal.metrics.DevNullMetricsProvider;
 import org.neo4j.driver.internal.reactive.InternalRxSession;
 import org.neo4j.driver.internal.security.SecurityPlan;
 import org.neo4j.driver.internal.types.InternalTypeSystem;
@@ -102,7 +103,7 @@ public Metrics metrics()
     @Override
     public boolean isMetricsEnabled()
     {
-        return metricsProvider.isMetricsEnabled();
+        return metricsProvider != DevNullMetricsProvider.INSTANCE;
     }
 
     @Override

driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImpl.java

@@ -47,6 +47,7 @@
 import org.neo4j.driver.internal.spi.ConnectionPool;
 import org.neo4j.driver.internal.util.Clock;
 import org.neo4j.driver.internal.util.Futures;
+import org.neo4j.driver.net.ServerAddress;
 
 import static java.lang.String.format;
 import static org.neo4j.driver.internal.async.connection.ChannelAttributes.setAuthorizationStateListener;
@@ -159,13 +160,13 @@ public void retainAll( Set<BoltServerAddress> addressesToRetain )
     }
 
     @Override
-    public int inUseConnections( BoltServerAddress address )
+    public int inUseConnections( ServerAddress address )
     {
         return nettyChannelTracker.inUseChannelCount( address );
     }
 
     @Override
-    public int idleConnections( BoltServerAddress address )
+    public int idleConnections( ServerAddress address )
     {
         return nettyChannelTracker.idleChannelCount( address );
     }
@@ -284,8 +285,8 @@ private ExtendedChannelPool getOrCreatePool( BoltServerAddress address )
                                       if ( pool == null )
                                       {
                                           pool = newPool( address );
-                                          // before the connection pool is added I can add the metrics for the pool.
-                                          metricsListener.putPoolMetrics( pool.id(), address, this );
+                                          // before the connection pool is added I can register the metrics for the pool.
+                                          metricsListener.registerPoolMetrics( pool.id(), address, () -> this.inUseConnections( address ), () -> this.idleConnections( address ) );
                                           addressToPool.put( address, pool );
                                       }
                                       return pool;

driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelTracker.java

@@ -37,6 +37,7 @@
 import org.neo4j.driver.internal.messaging.BoltProtocol;
 import org.neo4j.driver.internal.metrics.ListenerEvent;
 import org.neo4j.driver.internal.metrics.MetricsListener;
+import org.neo4j.driver.net.ServerAddress;
 
 import static org.neo4j.driver.internal.async.connection.ChannelAttributes.poolId;
 import static org.neo4j.driver.internal.async.connection.ChannelAttributes.serverAddress;
@@ -46,8 +47,8 @@ public class NettyChannelTracker implements ChannelPoolHandler
     private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
     private final Lock read = lock.readLock();
     private final Lock write = lock.writeLock();
-    private final Map<BoltServerAddress,Integer> addressToInUseChannelCount = new HashMap<>();
-    private final Map<BoltServerAddress,Integer> addressToIdleChannelCount = new HashMap<>();
+    private final Map<ServerAddress,Integer> addressToInUseChannelCount = new HashMap<>();
+    private final Map<ServerAddress,Integer> addressToIdleChannelCount = new HashMap<>();
     private final Logger log;
     private final MetricsListener metricsListener;
     private final ChannelFutureListener closeListener = future -> channelClosed( future.channel() );
@@ -152,12 +153,12 @@ public void channelClosed( Channel channel )
         metricsListener.afterClosed( poolId( channel ) );
     }
 
-    public int inUseChannelCount( BoltServerAddress address )
+    public int inUseChannelCount( ServerAddress address )
     {
         return retrieveInReadLock( () -> addressToInUseChannelCount.getOrDefault( address, 0 ) );
     }
 
-    public int idleChannelCount( BoltServerAddress address )
+    public int idleChannelCount( ServerAddress address )
     {
         return retrieveInReadLock( () -> addressToIdleChannelCount.getOrDefault( address, 0 ) );
     }
@@ -213,9 +214,9 @@ private void decrementIdle( Channel channel )
         addressToIdleChannelCount.put( address, count - 1 );
     }
 
-    private void increment( Channel channel, Map<BoltServerAddress,Integer> countMap )
+    private void increment( Channel channel, Map<ServerAddress,Integer> countMap )
     {
-        BoltServerAddress address = serverAddress( channel );
+        ServerAddress address = serverAddress( channel );
         Integer count = countMap.computeIfAbsent( address, k -> 0 );
         countMap.put( address, count + 1 );
     }