Merge pull request #14787 from vespa-engine/bjorncs/jetty-threadpool-metrics

Bjorncs/jetty threadpool metrics

14 files changed, 271 insertions, 219 deletions

diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/HttpRequestDispatch.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/HttpRequestDispatch.java
index cc7ed7ac3e0..2cab06e9e23 100644
--- a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/HttpRequestDispatch.java
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/HttpRequestDispatch.java
@@ -54,7 +54,7 @@ class HttpRequestDispatch {
 
     private final ServletResponseController servletResponseController;
     private final RequestHandler requestHandler;
-    private final MetricReporter metricReporter;
+    private final RequestMetricReporter metricReporter;
 
     public HttpRequestDispatch(JDiscContext jDiscContext,
                                AccessLogEntry accessLogEntry,
@@ -66,7 +66,7 @@ class HttpRequestDispatch {
         requestHandler = newRequestHandler(jDiscContext, accessLogEntry, servletRequest);
 
         this.jettyRequest = (Request) servletRequest;
-        this.metricReporter = new MetricReporter(jDiscContext.metric, metricContext, jettyRequest.getTimeStamp());
+        this.metricReporter = new RequestMetricReporter(jDiscContext.metric, metricContext, jettyRequest.getTimeStamp());
         this.servletResponseController = new ServletResponseController(servletRequest,
                                                                        servletResponse,
                                                                        jDiscContext.janitor,
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/HttpResponseStatisticsCollector.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/HttpResponseStatisticsCollector.java
index 31a8303ab4b..82c445c7ca9 100644
--- a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/HttpResponseStatisticsCollector.java
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/HttpResponseStatisticsCollector.java
@@ -2,7 +2,6 @@
 package com.yahoo.jdisc.http.server.jetty;
 
 import com.yahoo.jdisc.http.HttpRequest;
-import com.yahoo.jdisc.http.server.jetty.JettyHttpServer.Metrics;
 import org.eclipse.jetty.http.HttpStatus;
 import org.eclipse.jetty.server.AsyncContextEvent;
 import org.eclipse.jetty.server.Handler;
@@ -51,13 +50,13 @@ public class HttpResponseStatisticsCollector extends HandlerWrapper implements G
     }
 
     private static final String[] HTTP_RESPONSE_GROUPS = {
-            Metrics.RESPONSES_1XX,
-            Metrics.RESPONSES_2XX,
-            Metrics.RESPONSES_3XX,
-            Metrics.RESPONSES_4XX,
-            Metrics.RESPONSES_5XX,
-            Metrics.RESPONSES_401,
-            Metrics.RESPONSES_403
+            MetricDefinitions.RESPONSES_1XX,
+            MetricDefinitions.RESPONSES_2XX,
+            MetricDefinitions.RESPONSES_3XX,
+            MetricDefinitions.RESPONSES_4XX,
+            MetricDefinitions.RESPONSES_5XX,
+            MetricDefinitions.RESPONSES_401,
+            MetricDefinitions.RESPONSES_403
     };
 
     private final AtomicLong inFlight = new AtomicLong();
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JDiscHttpServlet.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JDiscHttpServlet.java
index dfbcfb741f5..8ffc6759ae7 100644
--- a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JDiscHttpServlet.java
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JDiscHttpServlet.java
@@ -87,8 +87,8 @@ class JDiscHttpServlet extends HttpServlet {
         request.setAttribute(JDiscServerConnector.REQUEST_ATTRIBUTE, getConnector(request));
 
         Metric.Context metricContext = getMetricContext(request);
-        context.metric.add(JettyHttpServer.Metrics.NUM_REQUESTS, 1, metricContext);
-        context.metric.add(JettyHttpServer.Metrics.JDISC_HTTP_REQUESTS, 1, metricContext);
+        context.metric.add(MetricDefinitions.NUM_REQUESTS, 1, metricContext);
+        context.metric.add(MetricDefinitions.JDISC_HTTP_REQUESTS, 1, metricContext);
 
         String method = request.getMethod().toUpperCase();
         if (servletSupportedMethods.contains(method)) {
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JDiscServerConnector.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JDiscServerConnector.java
index 824a8cda330..f82b51804a9 100644
--- a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JDiscServerConnector.java
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JDiscServerConnector.java
@@ -75,8 +75,8 @@ class JDiscServerConnector extends ServerConnector {
         var requestDimensions = new RequestDimensions(method, scheme);
         return requestMetricContextCache.computeIfAbsent(requestDimensions, ignored -> {
             Map<String, Object> dimensions = createConnectorDimensions(listenPort, connectorName);
-            dimensions.put(JettyHttpServer.Metrics.METHOD_DIMENSION, method);
-            dimensions.put(JettyHttpServer.Metrics.SCHEME_DIMENSION, scheme);
+            dimensions.put(MetricDefinitions.METHOD_DIMENSION, method);
+            dimensions.put(MetricDefinitions.SCHEME_DIMENSION, scheme);
             return metric.createContext(dimensions);
         });
     }
@@ -95,8 +95,8 @@ class JDiscServerConnector extends ServerConnector {
 
     private static Map<String, Object> createConnectorDimensions(int listenPort, String connectorName) {
         Map<String, Object> props = new HashMap<>();
-        props.put(JettyHttpServer.Metrics.NAME_DIMENSION, connectorName);
-        props.put(JettyHttpServer.Metrics.PORT_DIMENSION, listenPort);
+        props.put(MetricDefinitions.NAME_DIMENSION, connectorName);
+        props.put(MetricDefinitions.PORT_DIMENSION, listenPort);
         return props;
     }
 
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JettyHttpServer.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JettyHttpServer.java
index 45dc9144ffe..303b36430a5 100644
--- a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JettyHttpServer.java
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/JettyHttpServer.java
@@ -1,11 +1,10 @@
 // Copyright 2018 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 package com.yahoo.jdisc.http.server.jetty;
 
-import com.google.common.annotations.Beta;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import com.google.inject.Inject;
 import com.yahoo.component.ComponentId;
 import com.yahoo.component.provider.ComponentRegistry;
+import com.yahoo.concurrent.DaemonThreadFactory;
 import com.yahoo.container.logging.AccessLog;
 import com.yahoo.jdisc.Metric;
 import com.yahoo.jdisc.http.ConnectorConfig;
@@ -15,7 +14,6 @@ import com.yahoo.jdisc.http.server.FilterBindings;
 import com.yahoo.jdisc.service.AbstractServerProvider;
 import com.yahoo.jdisc.service.CurrentContainer;
 import org.eclipse.jetty.http.HttpField;
-import org.eclipse.jetty.io.ConnectionStatistics;
 import org.eclipse.jetty.jmx.ConnectorServer;
 import org.eclipse.jetty.jmx.MBeanContainer;
 import org.eclipse.jetty.server.Connector;
@@ -23,7 +21,6 @@ import org.eclipse.jetty.server.Handler;
 import org.eclipse.jetty.server.Server;
 import org.eclipse.jetty.server.ServerConnector;
 import org.eclipse.jetty.server.SslConnectionFactory;
-import org.eclipse.jetty.server.handler.AbstractHandlerContainer;
 import org.eclipse.jetty.server.handler.HandlerCollection;
 import org.eclipse.jetty.server.handler.StatisticsHandler;
 import org.eclipse.jetty.server.handler.gzip.GzipHandler;
@@ -44,14 +41,9 @@ import java.net.MalformedURLException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.EnumSet;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
@@ -62,77 +54,21 @@ import static java.util.stream.Collectors.toList;
  * @author Simon Thoresen Hult
  * @author bjorncs
  */
-@Beta
 public class JettyHttpServer extends AbstractServerProvider {
 
-    public interface Metrics {
-        String NAME_DIMENSION = "serverName";
-        String PORT_DIMENSION = "serverPort";
-        String METHOD_DIMENSION = "httpMethod";
-        String SCHEME_DIMENSION = "scheme";
-        String REQUEST_TYPE_DIMENSION = "requestType";
-        String CLIENT_IP_DIMENSION = "clientIp";
-
-        String NUM_OPEN_CONNECTIONS = "serverNumOpenConnections";
-        String NUM_CONNECTIONS_OPEN_MAX = "serverConnectionsOpenMax";
-        String CONNECTION_DURATION_MAX = "serverConnectionDurationMax";
-        String CONNECTION_DURATION_MEAN = "serverConnectionDurationMean";
-        String CONNECTION_DURATION_STD_DEV = "serverConnectionDurationStdDev";
-        String NUM_PREMATURELY_CLOSED_CONNECTIONS = "jdisc.http.request.prematurely_closed";
-
-        String NUM_BYTES_RECEIVED = "serverBytesReceived";
-        String NUM_BYTES_SENT     = "serverBytesSent";
-
-        String NUM_CONNECTIONS = "serverNumConnections";
-
-        /* For historical reasons, these are all aliases for the same metric. 'jdisc.http' should ideally be the only one. */
-        String JDISC_HTTP_REQUESTS = "jdisc.http.requests";
-        String NUM_REQUESTS = "serverNumRequests";
-
-        String NUM_SUCCESSFUL_RESPONSES = "serverNumSuccessfulResponses";
-        String NUM_FAILED_RESPONSES = "serverNumFailedResponses";
-        String NUM_SUCCESSFUL_WRITES = "serverNumSuccessfulResponseWrites";
-        String NUM_FAILED_WRITES = "serverNumFailedResponseWrites";
-
-        String TOTAL_SUCCESSFUL_LATENCY = "serverTotalSuccessfulResponseLatency";
-        String TOTAL_FAILED_LATENCY = "serverTotalFailedResponseLatency";
-        String TIME_TO_FIRST_BYTE = "serverTimeToFirstByte";
-
-        String RESPONSES_1XX = "http.status.1xx";
-        String RESPONSES_2XX = "http.status.2xx";
-        String RESPONSES_3XX = "http.status.3xx";
-        String RESPONSES_4XX = "http.status.4xx";
-        String RESPONSES_5XX = "http.status.5xx";
-        String RESPONSES_401 = "http.status.401";
-        String RESPONSES_403 = "http.status.403";
-
-        String STARTED_MILLIS = "serverStartedMillis";
-
-        String URI_LENGTH = "jdisc.http.request.uri_length";
-        String CONTENT_SIZE = "jdisc.http.request.content_size";
-
-        String SSL_HANDSHAKE_FAILURE_MISSING_CLIENT_CERT = "jdisc.http.ssl.handshake.failure.missing_client_cert";
-        String SSL_HANDSHAKE_FAILURE_EXPIRED_CLIENT_CERT = "jdisc.http.ssl.handshake.failure.expired_client_cert";
-        String SSL_HANDSHAKE_FAILURE_INVALID_CLIENT_CERT = "jdisc.http.ssl.handshake.failure.invalid_client_cert";
-        String SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_PROTOCOLS = "jdisc.http.ssl.handshake.failure.incompatible_protocols";
-        String SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_CIPHERS = "jdisc.http.ssl.handshake.failure.incompatible_ciphers";
-        String SSL_HANDSHAKE_FAILURE_UNKNOWN = "jdisc.http.ssl.handshake.failure.unknown";
-    }
-
     private final static Logger log = Logger.getLogger(JettyHttpServer.class.getName());
-    private final long timeStarted = System.currentTimeMillis();
+
     private final ExecutorService janitor;
-    private final ScheduledExecutorService metricReporterExecutor;
-    private final Metric metric;
+
     private final Server server;
     private final List<Integer> listenedPorts = new ArrayList<>();
+    private final ServerMetricReporter metricsReporter;
 
     @Inject
     public JettyHttpServer(CurrentContainer container,
                            Metric metric,
                            ServerConfig serverConfig,
                            ServletPathsConfig servletPathsConfig,
-                           ThreadFactory threadFactory,
                            FilterBindings filterBindings,
                            ComponentRegistry<ConnectorFactory> connectorFactories,
                            ComponentRegistry<ServletHolder> servletHolders,
@@ -141,7 +77,6 @@ public class JettyHttpServer extends AbstractServerProvider {
         super(container);
         if (connectorFactories.allComponents().isEmpty())
             throw new IllegalArgumentException("No connectors configured.");
-        this.metric = metric;
 
         initializeJettyLogging();
 
@@ -157,7 +92,7 @@ public class JettyHttpServer extends AbstractServerProvider {
             listenedPorts.add(connectorConfig.listenPort());
         }
 
-        janitor = newJanitor(threadFactory);
+        janitor = newJanitor();
 
         JDiscContext jDiscContext = new JDiscContext(filterBindings.getRequestFilters().activate(),
                                                      filterBindings.getResponseFilters().activate(),
@@ -179,16 +114,7 @@ public class JettyHttpServer extends AbstractServerProvider {
                                                jdiscServlet,
                                                servletHolders,
                                                jDiscFilterInvokerFilter));
-
-        int numMetricReporterThreads = 1;
-        metricReporterExecutor =
-                Executors.newScheduledThreadPool(numMetricReporterThreads,
-                                                 new ThreadFactoryBuilder()
-                                                         .setDaemon(true)
-                                                         .setNameFormat(JettyHttpServer.class.getName() + "-MetricReporter-%d")
-                                                         .setThreadFactory(threadFactory)
-                                                         .build());
-        metricReporterExecutor.scheduleAtFixedRate(new MetricTask(), 0, 2, TimeUnit.SECONDS);
+        this.metricsReporter = new ServerMetricReporter(metric, server);
     }
 
     private static void initializeJettyLogging() {
@@ -274,23 +200,19 @@ public class JettyHttpServer extends AbstractServerProvider {
         return ports.stream().map(Object::toString).collect(Collectors.joining(":"));
     }
 
-    private static ExecutorService newJanitor(ThreadFactory factory) {
+    private static ExecutorService newJanitor() {
         int threadPoolSize = Runtime.getRuntime().availableProcessors();
         log.info("Creating janitor executor with " + threadPoolSize + " threads");
         return Executors.newFixedThreadPool(
                 threadPoolSize,
-                new ThreadFactoryBuilder()
-                        .setDaemon(true)
-                        .setNameFormat(JettyHttpServer.class.getName() + "-Janitor-%d")
-                        .setThreadFactory(factory)
-                        .build()
-        );
+                new DaemonThreadFactory(JettyHttpServer.class.getName() + "-Janitor-"));
     }
 
     @Override
     public void start() {
         try {
             server.start();
+            metricsReporter.start();
             logEffectiveSslConfiguration();
         } catch (final Exception e) {
             if (e instanceof IOException && e.getCause() instanceof BindException) {
@@ -326,7 +248,7 @@ public class JettyHttpServer extends AbstractServerProvider {
             log.log(Level.SEVERE, "Server shutdown threw an unexpected exception.", e);
         }
 
-        metricReporterExecutor.shutdown();
+        metricsReporter.shutdown();
         janitor.shutdown();
     }
 
@@ -340,56 +262,6 @@ public class JettyHttpServer extends AbstractServerProvider {
 
     Server server() { return server; }
 
-    private class MetricTask implements Runnable {
-        @Override
-        public void run() {
-            HttpResponseStatisticsCollector statisticsCollector = ((AbstractHandlerContainer) server.getHandler())
-                    .getChildHandlerByClass(HttpResponseStatisticsCollector.class);
-            if (statisticsCollector != null) {
-                setServerMetrics(statisticsCollector);
-            }
-
-            // reset statisticsHandler to preserve earlier behavior
-            StatisticsHandler statisticsHandler = ((AbstractHandlerContainer) server.getHandler())
-                    .getChildHandlerByClass(StatisticsHandler.class);
-            if (statisticsHandler != null) {
-                statisticsHandler.statsReset();
-            }
-
-            for (Connector connector : server.getConnectors()) {
-                setConnectorMetrics((JDiscServerConnector)connector);
-            }
-        }
-
-    }
-
-    private void setServerMetrics(HttpResponseStatisticsCollector statisticsCollector) {
-        long timeSinceStarted = System.currentTimeMillis() - timeStarted;
-        metric.set(Metrics.STARTED_MILLIS, timeSinceStarted, null);
-
-        addResponseMetrics(statisticsCollector);
-    }
-
-    private void addResponseMetrics(HttpResponseStatisticsCollector statisticsCollector) {
-        for (var metricEntry : statisticsCollector.takeStatistics()) {
-            Map<String, Object> dimensions = new HashMap<>();
-            dimensions.put(Metrics.METHOD_DIMENSION, metricEntry.method);
-            dimensions.put(Metrics.SCHEME_DIMENSION, metricEntry.scheme);
-            dimensions.put(Metrics.REQUEST_TYPE_DIMENSION, metricEntry.requestType);
-            metric.add(metricEntry.name, metricEntry.value, metric.createContext(dimensions));
-        }
-    }
-
-    private void setConnectorMetrics(JDiscServerConnector connector) {
-        ConnectionStatistics statistics = connector.getStatistics();
-        metric.set(Metrics.NUM_CONNECTIONS, statistics.getConnectionsTotal(), connector.getConnectorMetricContext());
-        metric.set(Metrics.NUM_OPEN_CONNECTIONS, statistics.getConnections(), connector.getConnectorMetricContext());
-        metric.set(Metrics.NUM_CONNECTIONS_OPEN_MAX, statistics.getConnectionsMax(), connector.getConnectorMetricContext());
-        metric.set(Metrics.CONNECTION_DURATION_MAX, statistics.getConnectionDurationMax(), connector.getConnectorMetricContext());
-        metric.set(Metrics.CONNECTION_DURATION_MEAN, statistics.getConnectionDurationMean(), connector.getConnectorMetricContext());
-        metric.set(Metrics.CONNECTION_DURATION_STD_DEV, statistics.getConnectionDurationStdDev(), connector.getConnectorMetricContext());
-    }
-
     private StatisticsHandler newStatisticsHandler() {
         StatisticsHandler statisticsHandler = new StatisticsHandler();
         statisticsHandler.statsReset();
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/MetricDefinitions.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/MetricDefinitions.java
new file mode 100644
index 00000000000..a55a6e8a734
--- /dev/null
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/MetricDefinitions.java
@@ -0,0 +1,71 @@
+// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.server.jetty;
+
+/**
+ * Name and dimensions for jdisc/container metrics
+ *
+ * @author bjorncs
+ */
+class MetricDefinitions {
+    static final String NAME_DIMENSION = "serverName";
+    static final String PORT_DIMENSION = "serverPort";
+    static final String METHOD_DIMENSION = "httpMethod";
+    static final String SCHEME_DIMENSION = "scheme";
+    static final String REQUEST_TYPE_DIMENSION = "requestType";
+    static final String CLIENT_IP_DIMENSION = "clientIp";
+
+    static final String NUM_OPEN_CONNECTIONS = "serverNumOpenConnections";
+    static final String NUM_CONNECTIONS_OPEN_MAX = "serverConnectionsOpenMax";
+    static final String CONNECTION_DURATION_MAX = "serverConnectionDurationMax";
+    static final String CONNECTION_DURATION_MEAN = "serverConnectionDurationMean";
+    static final String CONNECTION_DURATION_STD_DEV = "serverConnectionDurationStdDev";
+    static final String NUM_PREMATURELY_CLOSED_CONNECTIONS = "jdisc.http.request.prematurely_closed";
+
+    static final String NUM_BYTES_RECEIVED = "serverBytesReceived";
+    static final String NUM_BYTES_SENT     = "serverBytesSent";
+
+    static final String NUM_CONNECTIONS = "serverNumConnections";
+
+    /* For historical reasons, these are all aliases for the same metric. 'jdisc.http' should ideally be the only one. */
+    static final String JDISC_HTTP_REQUESTS = "jdisc.http.requests";
+    static final String NUM_REQUESTS = "serverNumRequests";
+
+    static final String NUM_SUCCESSFUL_RESPONSES = "serverNumSuccessfulResponses";
+    static final String NUM_FAILED_RESPONSES = "serverNumFailedResponses";
+    static final String NUM_SUCCESSFUL_WRITES = "serverNumSuccessfulResponseWrites";
+    static final String NUM_FAILED_WRITES = "serverNumFailedResponseWrites";
+
+    static final String TOTAL_SUCCESSFUL_LATENCY = "serverTotalSuccessfulResponseLatency";
+    static final String TOTAL_FAILED_LATENCY = "serverTotalFailedResponseLatency";
+    static final String TIME_TO_FIRST_BYTE = "serverTimeToFirstByte";
+
+    static final String RESPONSES_1XX = "http.status.1xx";
+    static final String RESPONSES_2XX = "http.status.2xx";
+    static final String RESPONSES_3XX = "http.status.3xx";
+    static final String RESPONSES_4XX = "http.status.4xx";
+    static final String RESPONSES_5XX = "http.status.5xx";
+    static final String RESPONSES_401 = "http.status.401";
+    static final String RESPONSES_403 = "http.status.403";
+
+    static final String STARTED_MILLIS = "serverStartedMillis";
+
+    static final String URI_LENGTH = "jdisc.http.request.uri_length";
+    static final String CONTENT_SIZE = "jdisc.http.request.content_size";
+
+    static final String SSL_HANDSHAKE_FAILURE_MISSING_CLIENT_CERT = "jdisc.http.ssl.handshake.failure.missing_client_cert";
+    static final String SSL_HANDSHAKE_FAILURE_EXPIRED_CLIENT_CERT = "jdisc.http.ssl.handshake.failure.expired_client_cert";
+    static final String SSL_HANDSHAKE_FAILURE_INVALID_CLIENT_CERT = "jdisc.http.ssl.handshake.failure.invalid_client_cert";
+    static final String SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_PROTOCOLS = "jdisc.http.ssl.handshake.failure.incompatible_protocols";
+    static final String SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_CIPHERS = "jdisc.http.ssl.handshake.failure.incompatible_ciphers";
+    static final String SSL_HANDSHAKE_FAILURE_UNKNOWN = "jdisc.http.ssl.handshake.failure.unknown";
+
+    static final String JETTY_THREADPOOL_MAX_THREADS = "jdisc.http.jetty.threadpool.thread.max";
+    static final String JETTY_THREADPOOL_MIN_THREADS = "jdisc.http.jetty.threadpool.thread.min";
+    static final String JETTY_THREADPOOL_RESERVED_THREADS = "jdisc.http.jetty.threadpool.thread.reserved";
+    static final String JETTY_THREADPOOL_BUSY_THREADS = "jdisc.http.jetty.threadpool.thread.busy";
+    static final String JETTY_THREADPOOL_IDLE_THREADS = "jdisc.http.jetty.threadpool.thread.idle";
+    static final String JETTY_THREADPOOL_TOTAL_THREADS = "jdisc.http.jetty.threadpool.thread.total";
+    static final String JETTY_THREADPOOL_QUEUE_SIZE = "jdisc.http.jetty.threadpool.queue.size";
+
+    private MetricDefinitions() {}
+}
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/MetricReporter.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/RequestMetricReporter.java
index 21a64792731..7596be0415a 100644
--- a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/MetricReporter.java
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/RequestMetricReporter.java
@@ -4,8 +4,6 @@ package com.yahoo.jdisc.http.server.jetty;
 import com.yahoo.jdisc.Metric;
 import com.yahoo.jdisc.Metric.Context;
 
-import com.yahoo.jdisc.http.server.jetty.JettyHttpServer.Metrics;
-
 import java.util.concurrent.atomic.AtomicBoolean;
 
 
@@ -13,7 +11,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
  * Responsible for metric reporting for JDisc http request handler support.
  * @author Tony Vaagenes
  */
-public class MetricReporter {
+class RequestMetricReporter {
     private final Metric metric;
     private final Context context;
 
@@ -23,65 +21,65 @@ public class MetricReporter {
     private final AtomicBoolean firstSetOfTimeToFirstByte = new AtomicBoolean(true);
 
 
-    public MetricReporter(Metric metric, Context context, long requestStartTime) {
+    RequestMetricReporter(Metric metric, Context context, long requestStartTime) {
         this.metric = metric;
         this.context = context;
         this.requestStartTime = requestStartTime;
     }
 
-    public void successfulWrite(int numBytes) {
+    void successfulWrite(int numBytes) {
         setTimeToFirstByteFirstTime();
 
-        metric.add(Metrics.NUM_SUCCESSFUL_WRITES, 1, context);
-        metric.set(Metrics.NUM_BYTES_SENT, numBytes, context);
+        metric.add(MetricDefinitions.NUM_SUCCESSFUL_WRITES, 1, context);
+        metric.set(MetricDefinitions.NUM_BYTES_SENT, numBytes, context);
     }
 
     private void setTimeToFirstByteFirstTime() {
         boolean isFirstWrite = firstSetOfTimeToFirstByte.getAndSet(false);
         if (isFirstWrite) {
             long timeToFirstByte = getRequestLatency();
-            metric.set(Metrics.TIME_TO_FIRST_BYTE, timeToFirstByte, context);
+            metric.set(MetricDefinitions.TIME_TO_FIRST_BYTE, timeToFirstByte, context);
         }
     }
 
-    public void failedWrite() {
-        metric.add(Metrics.NUM_FAILED_WRITES, 1, context);
+    void failedWrite() {
+        metric.add(MetricDefinitions.NUM_FAILED_WRITES, 1, context);
     }
 
-    public void successfulResponse() {
+    void successfulResponse() {
         setTimeToFirstByteFirstTime();
 
         long requestLatency = getRequestLatency();
 
-        metric.set(Metrics.TOTAL_SUCCESSFUL_LATENCY, requestLatency, context);
+        metric.set(MetricDefinitions.TOTAL_SUCCESSFUL_LATENCY, requestLatency, context);
 
-        metric.add(Metrics.NUM_SUCCESSFUL_RESPONSES, 1, context);
+        metric.add(MetricDefinitions.NUM_SUCCESSFUL_RESPONSES, 1, context);
     }
 
-    public void failedResponse() {
+    void failedResponse() {
         setTimeToFirstByteFirstTime();
 
-        metric.set(Metrics.TOTAL_FAILED_LATENCY, getRequestLatency(), context);
-        metric.add(Metrics.NUM_FAILED_RESPONSES, 1, context);
+        metric.set(MetricDefinitions.TOTAL_FAILED_LATENCY, getRequestLatency(), context);
+        metric.add(MetricDefinitions.NUM_FAILED_RESPONSES, 1, context);
     }
 
-    public void prematurelyClosed() {
-        metric.add(Metrics.NUM_PREMATURELY_CLOSED_CONNECTIONS, 1, context);
+    void prematurelyClosed() {
+        metric.add(MetricDefinitions.NUM_PREMATURELY_CLOSED_CONNECTIONS, 1, context);
     }
 
-    public void successfulRead(int bytes_received) {
-        metric.set(JettyHttpServer.Metrics.NUM_BYTES_RECEIVED, bytes_received, context);
+    void successfulRead(int bytes_received) {
+        metric.set(MetricDefinitions.NUM_BYTES_RECEIVED, bytes_received, context);
     }
 
     private long getRequestLatency() {
         return System.currentTimeMillis() - requestStartTime;
     }
 
-    public void uriLength(int length) {
-        metric.set(Metrics.URI_LENGTH, length, context);
+    void uriLength(int length) {
+        metric.set(MetricDefinitions.URI_LENGTH, length, context);
     }
 
-    public void contentSize(int size) {
-        metric.set(Metrics.CONTENT_SIZE, size, context);
+    void contentSize(int size) {
+        metric.set(MetricDefinitions.CONTENT_SIZE, size, context);
     }
 }
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServerMetricReporter.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServerMetricReporter.java
new file mode 100644
index 00000000000..ba3694ffc2f
--- /dev/null
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServerMetricReporter.java
@@ -0,0 +1,115 @@
+// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jdisc.http.server.jetty;
+
+import com.yahoo.concurrent.DaemonThreadFactory;
+import com.yahoo.jdisc.Metric;
+import org.eclipse.jetty.io.ConnectionStatistics;
+import org.eclipse.jetty.server.Connector;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.handler.AbstractHandlerContainer;
+import org.eclipse.jetty.server.handler.StatisticsHandler;
+import org.eclipse.jetty.util.thread.QueuedThreadPool;
+
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Reports server/connector specific metrics for Jdisc and Jetty
+ *
+ * @author bjorncs
+ */
+class ServerMetricReporter {
+
+    private final ScheduledExecutorService executor =
+            Executors.newScheduledThreadPool(1, new DaemonThreadFactory("jdisc-jetty-metric-reporter-"));
+    private final Metric metric;
+    private final Server jetty;
+
+    ServerMetricReporter(Metric metric, Server jetty) {
+        this.metric = metric;
+        this.jetty = jetty;
+    }
+
+    void start() {
+        executor.scheduleAtFixedRate(new ReporterTask(), 0, 2, TimeUnit.SECONDS);
+    }
+
+    void shutdown() {
+        try {
+            executor.shutdownNow();
+            executor.awaitTermination(10, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private class ReporterTask implements Runnable {
+
+        private final Instant timeStarted = Instant.now();
+
+        @Override
+        public void run() {
+            HttpResponseStatisticsCollector statisticsCollector = ((AbstractHandlerContainer) jetty.getHandler())
+                    .getChildHandlerByClass(HttpResponseStatisticsCollector.class);
+            if (statisticsCollector != null) {
+                setServerMetrics(statisticsCollector);
+            }
+
+            // reset statisticsHandler to preserve earlier behavior
+            StatisticsHandler statisticsHandler = ((AbstractHandlerContainer) jetty.getHandler())
+                    .getChildHandlerByClass(StatisticsHandler.class);
+            if (statisticsHandler != null) {
+                statisticsHandler.statsReset();
+            }
+
+            for (Connector connector : jetty.getConnectors()) {
+                setConnectorMetrics((JDiscServerConnector)connector);
+            }
+
+            setJettyThreadpoolMetrics();
+        }
+
+        private void setServerMetrics(HttpResponseStatisticsCollector statisticsCollector) {
+            long timeSinceStarted = System.currentTimeMillis() - timeStarted.toEpochMilli();
+            metric.set(MetricDefinitions.STARTED_MILLIS, timeSinceStarted, null);
+
+            addResponseMetrics(statisticsCollector);
+        }
+
+        private void addResponseMetrics(HttpResponseStatisticsCollector statisticsCollector) {
+            for (var metricEntry : statisticsCollector.takeStatistics()) {
+                Map<String, Object> dimensions = new HashMap<>();
+                dimensions.put(MetricDefinitions.METHOD_DIMENSION, metricEntry.method);
+                dimensions.put(MetricDefinitions.SCHEME_DIMENSION, metricEntry.scheme);
+                dimensions.put(MetricDefinitions.REQUEST_TYPE_DIMENSION, metricEntry.requestType);
+                metric.add(metricEntry.name, metricEntry.value, metric.createContext(dimensions));
+            }
+        }
+
+        private void setJettyThreadpoolMetrics() {
+            QueuedThreadPool threadpool = (QueuedThreadPool) jetty.getThreadPool();
+            metric.set(MetricDefinitions.JETTY_THREADPOOL_MAX_THREADS, threadpool.getMaxThreads(), null);
+            metric.set(MetricDefinitions.JETTY_THREADPOOL_MIN_THREADS, threadpool.getMinThreads(), null);
+            metric.set(MetricDefinitions.JETTY_THREADPOOL_RESERVED_THREADS, threadpool.getReservedThreads(), null);
+            metric.set(MetricDefinitions.JETTY_THREADPOOL_BUSY_THREADS, threadpool.getBusyThreads(), null);
+            metric.set(MetricDefinitions.JETTY_THREADPOOL_IDLE_THREADS, threadpool.getIdleThreads(), null);
+            metric.set(MetricDefinitions.JETTY_THREADPOOL_TOTAL_THREADS, threadpool.getThreads(), null);
+            metric.set(MetricDefinitions.JETTY_THREADPOOL_QUEUE_SIZE, threadpool.getQueueSize(), null);
+        }
+
+        private void setConnectorMetrics(JDiscServerConnector connector) {
+            ConnectionStatistics statistics = connector.getStatistics();
+            metric.set(MetricDefinitions.NUM_CONNECTIONS, statistics.getConnectionsTotal(), connector.getConnectorMetricContext());
+            metric.set(MetricDefinitions.NUM_OPEN_CONNECTIONS, statistics.getConnections(), connector.getConnectorMetricContext());
+            metric.set(MetricDefinitions.NUM_CONNECTIONS_OPEN_MAX, statistics.getConnectionsMax(), connector.getConnectorMetricContext());
+            metric.set(MetricDefinitions.CONNECTION_DURATION_MAX, statistics.getConnectionDurationMax(), connector.getConnectorMetricContext());
+            metric.set(MetricDefinitions.CONNECTION_DURATION_MEAN, statistics.getConnectionDurationMean(), connector.getConnectorMetricContext());
+            metric.set(MetricDefinitions.CONNECTION_DURATION_STD_DEV, statistics.getConnectionDurationStdDev(), connector.getConnectorMetricContext());
+        }
+
+    }
+}
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletOutputStreamWriter.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletOutputStreamWriter.java
index a764c75f766..b4d03385c3b 100644
--- a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletOutputStreamWriter.java
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletOutputStreamWriter.java
@@ -59,7 +59,7 @@ public class ServletOutputStreamWriter {
     // GuardedBy("monitor")
     private final Deque<ResponseContentPart> responseContentQueue = new ArrayDeque<>();
 
-    private final MetricReporter metricReporter;
+    private final RequestMetricReporter metricReporter;
 
     /**
      * When this future completes there will be no more calls against the servlet output stream or servlet response.
@@ -70,7 +70,7 @@ public class ServletOutputStreamWriter {
     final CompletableFuture<Void> finishedFuture = new CompletableFuture<>();
 
 
-    public ServletOutputStreamWriter(ServletOutputStream outputStream, Executor executor, MetricReporter metricReporter) {
+    public ServletOutputStreamWriter(ServletOutputStream outputStream, Executor executor, RequestMetricReporter metricReporter) {
         this.outputStream = outputStream;
         this.executor = executor;
         this.metricReporter = metricReporter;
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletRequestReader.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletRequestReader.java
index fd1f84f7d49..9e7912f2dc1 100644
--- a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletRequestReader.java
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletRequestReader.java
@@ -43,7 +43,7 @@ class ServletRequestReader implements ReadListener {
     private final ContentChannel requestContentChannel;
 
     private final Executor executor;
-    private final MetricReporter metricReporter;
+    private final RequestMetricReporter metricReporter;
 
     private int bytesRead;
 
@@ -94,7 +94,7 @@ class ServletRequestReader implements ReadListener {
             ServletInputStream servletInputStream,
             ContentChannel requestContentChannel,
             Executor executor,
-            MetricReporter metricReporter) {
+            RequestMetricReporter metricReporter) {
 
         Preconditions.checkNotNull(servletInputStream);
         Preconditions.checkNotNull(requestContentChannel);
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletResponseController.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletResponseController.java
index 5dd6b72dc20..60b7878156f 100644
--- a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletResponseController.java
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/ServletResponseController.java
@@ -58,7 +58,7 @@ public class ServletResponseController {
             HttpServletRequest servletRequest,
             HttpServletResponse servletResponse,
             Executor executor,
-            MetricReporter metricReporter,
+            RequestMetricReporter metricReporter,
             boolean developerMode) throws IOException {
 
         this.servletRequest = servletRequest;
diff --git a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/SslHandshakeFailedListener.java b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/SslHandshakeFailedListener.java
index fc9a6fc03be..4c9059b5b37 100644
--- a/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/SslHandshakeFailedListener.java
+++ b/jdisc_http_service/src/main/java/com/yahoo/jdisc/http/server/jetty/SslHandshakeFailedListener.java
@@ -2,7 +2,6 @@
 package com.yahoo.jdisc.http.server.jetty;
 
 import com.yahoo.jdisc.Metric;
-import com.yahoo.jdisc.http.server.jetty.JettyHttpServer.Metrics;
 import org.eclipse.jetty.io.ssl.SslHandshakeListener;
 
 import javax.net.ssl.SSLHandshakeException;
@@ -38,36 +37,36 @@ class SslHandshakeFailedListener implements SslHandshakeListener {
         log.log(Level.FINE, throwable, () -> "Ssl handshake failed: " + throwable.getMessage());
         String metricName = SslHandshakeFailure.fromSslHandshakeException((SSLHandshakeException) throwable)
                 .map(SslHandshakeFailure::metricName)
-                .orElse(Metrics.SSL_HANDSHAKE_FAILURE_UNKNOWN);
+                .orElse(MetricDefinitions.SSL_HANDSHAKE_FAILURE_UNKNOWN);
         metric.add(metricName, 1L, metric.createContext(createDimensions(event)));
     }
 
     private Map<String, Object> createDimensions(Event event) {
         Map<String, Object> dimensions = new HashMap<>();
-        dimensions.put(Metrics.NAME_DIMENSION, connectorName);
-        dimensions.put(Metrics.PORT_DIMENSION, listenPort);
+        dimensions.put(MetricDefinitions.NAME_DIMENSION, connectorName);
+        dimensions.put(MetricDefinitions.PORT_DIMENSION, listenPort);
         Optional.ofNullable(event.getSSLEngine().getPeerHost())
-                .ifPresent(clientIp -> dimensions.put(Metrics.CLIENT_IP_DIMENSION, clientIp));
+                .ifPresent(clientIp -> dimensions.put(MetricDefinitions.CLIENT_IP_DIMENSION, clientIp));
         return Map.copyOf(dimensions);
     }
 
     private enum SslHandshakeFailure {
         INCOMPATIBLE_PROTOCOLS(
-                Metrics.SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_PROTOCOLS,
+                MetricDefinitions.SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_PROTOCOLS,
                 "(Client requested protocol \\S+? is not enabled or supported in server context" +
                         "|The client supported protocol versions \\[\\S+?\\] are not accepted by server preferences \\[\\S+?\\])"),
         INCOMPATIBLE_CIPHERS(
-                Metrics.SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_CIPHERS,
+                MetricDefinitions.SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_CIPHERS,
                 "no cipher suites in common"),
         MISSING_CLIENT_CERT(
-                Metrics.SSL_HANDSHAKE_FAILURE_MISSING_CLIENT_CERT,
+                MetricDefinitions.SSL_HANDSHAKE_FAILURE_MISSING_CLIENT_CERT,
                 "Empty server certificate chain"),
         EXPIRED_CLIENT_CERTIFICATE(
-                Metrics.SSL_HANDSHAKE_FAILURE_EXPIRED_CLIENT_CERT,
+                MetricDefinitions.SSL_HANDSHAKE_FAILURE_EXPIRED_CLIENT_CERT,
                 // Note: this pattern will match certificates with too late notBefore as well
                 "PKIX path validation failed: java.security.cert.CertPathValidatorException: validity check failed"),
         INVALID_CLIENT_CERT(
-                Metrics.SSL_HANDSHAKE_FAILURE_INVALID_CLIENT_CERT, // Includes mismatch of client certificate and private key
+                MetricDefinitions.SSL_HANDSHAKE_FAILURE_INVALID_CLIENT_CERT, // Includes mismatch of client certificate and private key
                 "(PKIX path (building|validation) failed: .+)|(Invalid CertificateVerify signature)");
 
         private final String metricName;
diff --git a/jdisc_http_service/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpResponseStatisticsCollectorTest.java b/jdisc_http_service/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpResponseStatisticsCollectorTest.java
index 4ae824e2b7a..bb92d75bed5 100644
--- a/jdisc_http_service/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpResponseStatisticsCollectorTest.java
+++ b/jdisc_http_service/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpResponseStatisticsCollectorTest.java
@@ -2,7 +2,6 @@
 package com.yahoo.jdisc.http.server.jetty;
 
 import com.yahoo.jdisc.http.server.jetty.HttpResponseStatisticsCollector.StatisticsEntry;
-import com.yahoo.jdisc.http.server.jetty.JettyHttpServer.Metrics;
 import org.eclipse.jetty.http.HttpFields;
 import org.eclipse.jetty.http.HttpURI;
 import org.eclipse.jetty.http.HttpVersion;
@@ -48,8 +47,8 @@ public class HttpResponseStatisticsCollectorTest {
         testRequest("http", 200, "GET");
 
         var stats = collector.takeStatistics();
-        assertStatisticsEntryPresent(stats, "http", "GET", Metrics.RESPONSES_2XX, 1L);
-        assertStatisticsEntryPresent(stats, "http", "GET", Metrics.RESPONSES_3XX, 2L);
+        assertStatisticsEntryPresent(stats, "http", "GET", MetricDefinitions.RESPONSES_2XX, 1L);
+        assertStatisticsEntryPresent(stats, "http", "GET", MetricDefinitions.RESPONSES_3XX, 2L);
     }
 
     @Test
@@ -66,12 +65,12 @@ public class HttpResponseStatisticsCollectorTest {
         testRequest("https", 200, "POST");
 
         var stats = collector.takeStatistics();
-        assertStatisticsEntryPresent(stats, "http", "GET", Metrics.RESPONSES_2XX, 1L);
-        assertStatisticsEntryPresent(stats, "http", "GET", Metrics.RESPONSES_4XX, 1L);
-        assertStatisticsEntryPresent(stats, "http", "PUT", Metrics.RESPONSES_2XX, 1L);
-        assertStatisticsEntryPresent(stats, "http", "POST", Metrics.RESPONSES_2XX, 2L);
-        assertStatisticsEntryPresent(stats, "https", "GET", Metrics.RESPONSES_4XX, 1L);
-        assertStatisticsEntryPresent(stats, "https", "POST", Metrics.RESPONSES_2XX, 4L);
+        assertStatisticsEntryPresent(stats, "http", "GET", MetricDefinitions.RESPONSES_2XX, 1L);
+        assertStatisticsEntryPresent(stats, "http", "GET", MetricDefinitions.RESPONSES_4XX, 1L);
+        assertStatisticsEntryPresent(stats, "http", "PUT", MetricDefinitions.RESPONSES_2XX, 1L);
+        assertStatisticsEntryPresent(stats, "http", "POST", MetricDefinitions.RESPONSES_2XX, 2L);
+        assertStatisticsEntryPresent(stats, "https", "GET", MetricDefinitions.RESPONSES_4XX, 1L);
+        assertStatisticsEntryPresent(stats, "https", "POST", MetricDefinitions.RESPONSES_2XX, 4L);
     }
 
     @Test
@@ -81,9 +80,9 @@ public class HttpResponseStatisticsCollectorTest {
         testRequest("http", 403, "GET");
 
         var stats = collector.takeStatistics();
-        assertStatisticsEntryPresent(stats, "http", "GET", Metrics.RESPONSES_4XX, 3L);
-        assertStatisticsEntryPresent(stats, "http", "GET", Metrics.RESPONSES_401, 1L);
-        assertStatisticsEntryPresent(stats, "http", "GET", Metrics.RESPONSES_403, 1L);
+        assertStatisticsEntryPresent(stats, "http", "GET", MetricDefinitions.RESPONSES_4XX, 3L);
+        assertStatisticsEntryPresent(stats, "http", "GET", MetricDefinitions.RESPONSES_401, 1L);
+        assertStatisticsEntryPresent(stats, "http", "GET", MetricDefinitions.RESPONSES_403, 1L);
 
     }
 
@@ -93,12 +92,12 @@ public class HttpResponseStatisticsCollectorTest {
         testRequest("http", 200, "GET");
 
         var stats = collector.takeStatistics();
-        assertStatisticsEntryPresent(stats, "http", "GET", Metrics.RESPONSES_2XX, 2L);
+        assertStatisticsEntryPresent(stats, "http", "GET", MetricDefinitions.RESPONSES_2XX, 2L);
 
         testRequest("http", 200, "GET");
 
         stats = collector.takeStatistics();
-        assertStatisticsEntryPresent(stats, "http", "GET", Metrics.RESPONSES_2XX, 1L);
+        assertStatisticsEntryPresent(stats, "http", "GET", MetricDefinitions.RESPONSES_2XX, 1L);
     }
 
     @Test
@@ -109,15 +108,15 @@ public class HttpResponseStatisticsCollectorTest {
         testRequest("http", 200, "GET", "/status.html?foo=bar");
 
         var stats = collector.takeStatistics();
-        assertStatisticsEntryWithRequestTypePresent(stats, "http", "GET", Metrics.RESPONSES_2XX, "monitoring", 1L);
-        assertStatisticsEntryWithRequestTypePresent(stats, "http", "GET", Metrics.RESPONSES_2XX, "read", 1L);
-        assertStatisticsEntryWithRequestTypePresent(stats, "http", "POST", Metrics.RESPONSES_2XX, "read", 1L);
-        assertStatisticsEntryWithRequestTypePresent(stats, "http", "POST", Metrics.RESPONSES_2XX, "write", 1L);
+        assertStatisticsEntryWithRequestTypePresent(stats, "http", "GET", MetricDefinitions.RESPONSES_2XX, "monitoring", 1L);
+        assertStatisticsEntryWithRequestTypePresent(stats, "http", "GET", MetricDefinitions.RESPONSES_2XX, "read", 1L);
+        assertStatisticsEntryWithRequestTypePresent(stats, "http", "POST", MetricDefinitions.RESPONSES_2XX, "read", 1L);
+        assertStatisticsEntryWithRequestTypePresent(stats, "http", "POST", MetricDefinitions.RESPONSES_2XX, "write", 1L);
 
         testRequest("http", 200, "GET");
 
         stats = collector.takeStatistics();
-        assertStatisticsEntryPresent(stats, "http", "GET", Metrics.RESPONSES_2XX, 1L);
+        assertStatisticsEntryPresent(stats, "http", "GET", MetricDefinitions.RESPONSES_2XX, 1L);
     }
 
     @Test
@@ -125,7 +124,7 @@ public class HttpResponseStatisticsCollectorTest {
         testRequest("http", 200, "GET", "/search", com.yahoo.jdisc.Request.RequestType.WRITE);
 
         var stats = collector.takeStatistics();
-        assertStatisticsEntryWithRequestTypePresent(stats, "http", "GET", Metrics.RESPONSES_2XX, "write", 1L);
+        assertStatisticsEntryWithRequestTypePresent(stats, "http", "GET", MetricDefinitions.RESPONSES_2XX, "write", 1L);
     }
 
     @Before
diff --git a/jdisc_http_service/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpServerTest.java b/jdisc_http_service/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpServerTest.java
index 96cf1d4c01f..01ba776fbf0 100644
--- a/jdisc_http_service/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpServerTest.java
+++ b/jdisc_http_service/src/test/java/com/yahoo/jdisc/http/server/jetty/HttpServerTest.java
@@ -23,7 +23,6 @@ import com.yahoo.jdisc.http.Cookie;
 import com.yahoo.jdisc.http.HttpRequest;
 import com.yahoo.jdisc.http.HttpResponse;
 import com.yahoo.jdisc.http.ServerConfig;
-import com.yahoo.jdisc.http.server.jetty.JettyHttpServer.Metrics;
 import com.yahoo.jdisc.http.server.jetty.TestDrivers.TlsClientAuth;
 import com.yahoo.jdisc.service.BindingSetNotFoundException;
 import com.yahoo.security.KeyUtils;
@@ -657,7 +656,7 @@ public class HttpServerTest {
         assertHttpsRequestTriggersSslHandshakeException(
                 driver, clientCtx, null, null, "Received fatal alert: bad_certificate");
         verify(metricConsumer.mockitoMock())
-                .add(Metrics.SSL_HANDSHAKE_FAILURE_MISSING_CLIENT_CERT, 1L, MetricConsumerMock.STATIC_CONTEXT);
+                .add(MetricDefinitions.SSL_HANDSHAKE_FAILURE_MISSING_CLIENT_CERT, 1L, MetricConsumerMock.STATIC_CONTEXT);
         assertTrue(driver.close());
     }
 
@@ -677,7 +676,7 @@ public class HttpServerTest {
         assertHttpsRequestTriggersSslHandshakeException(
                 driver, clientCtx, "TLSv1.3", null, "Received fatal alert: protocol_version");
         verify(metricConsumer.mockitoMock())
-                .add(Metrics.SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_PROTOCOLS, 1L, MetricConsumerMock.STATIC_CONTEXT);
+                .add(MetricDefinitions.SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_PROTOCOLS, 1L, MetricConsumerMock.STATIC_CONTEXT);
         assertTrue(driver.close());
     }
 
@@ -697,7 +696,7 @@ public class HttpServerTest {
         assertHttpsRequestTriggersSslHandshakeException(
                 driver, clientCtx, null, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", "Received fatal alert: handshake_failure");
         verify(metricConsumer.mockitoMock())
-                .add(Metrics.SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_CIPHERS, 1L, MetricConsumerMock.STATIC_CONTEXT);
+                .add(MetricDefinitions.SSL_HANDSHAKE_FAILURE_INCOMPATIBLE_CIPHERS, 1L, MetricConsumerMock.STATIC_CONTEXT);
         assertTrue(driver.close());
     }
 
@@ -721,7 +720,7 @@ public class HttpServerTest {
         assertHttpsRequestTriggersSslHandshakeException(
                 driver, clientCtx, null, null, "Received fatal alert: certificate_unknown");
         verify(metricConsumer.mockitoMock())
-                .add(Metrics.SSL_HANDSHAKE_FAILURE_INVALID_CLIENT_CERT, 1L, MetricConsumerMock.STATIC_CONTEXT);
+                .add(MetricDefinitions.SSL_HANDSHAKE_FAILURE_INVALID_CLIENT_CERT, 1L, MetricConsumerMock.STATIC_CONTEXT);
         assertTrue(driver.close());
     }
 
@@ -744,7 +743,7 @@ public class HttpServerTest {
         assertHttpsRequestTriggersSslHandshakeException(
                 driver, clientCtx, null, null, "Received fatal alert: certificate_unknown");
         verify(metricConsumer.mockitoMock())
-                .add(Metrics.SSL_HANDSHAKE_FAILURE_EXPIRED_CLIENT_CERT, 1L, MetricConsumerMock.STATIC_CONTEXT);
+                .add(MetricDefinitions.SSL_HANDSHAKE_FAILURE_EXPIRED_CLIENT_CERT, 1L, MetricConsumerMock.STATIC_CONTEXT);
         assertTrue(driver.close());
     }