Lazy initialize HttpRouteStatsTracker in MethodHandlers (#114107)

We use about 1M for the route stats trackers instances per ES instance.
Making this lazy init should come at a trivial overhead and in fact
makes the computation of the node stats cheaper by saving spurious sums
on 0-valued long adders.

Author: original-brownbear

server/src/main/java/org/elasticsearch/http/HttpRouteStats.java

@@ -49,6 +49,8 @@ public record HttpRouteStats(
     long[] responseTimeHistogram
 ) implements Writeable, ToXContentObject {
 
+    public static final HttpRouteStats EMPTY = new HttpRouteStats(0, 0, new long[0], 0, 0, new long[0], new long[0]);
+
     public HttpRouteStats(StreamInput in) throws IOException {
         this(in.readVLong(), in.readVLong(), in.readVLongArray(), in.readVLong(), in.readVLong(), in.readVLongArray(), in.readVLongArray());
     }

server/src/main/java/org/elasticsearch/rest/MethodHandlers.java

@@ -13,6 +13,8 @@
 import org.elasticsearch.http.HttpRouteStats;
 import org.elasticsearch.http.HttpRouteStatsTracker;
 
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
 import java.util.EnumMap;
 import java.util.Map;
 import java.util.Set;
@@ -25,7 +27,18 @@ final class MethodHandlers {
     private final String path;
     private final Map<RestRequest.Method, Map<RestApiVersion, RestHandler>> methodHandlers;
 
-    private final HttpRouteStatsTracker statsTracker = new HttpRouteStatsTracker();
+    @SuppressWarnings("unused") // only accessed via #STATS_TRACKER_HANDLE, lazy initialized because instances consume non-trivial heap
+    private volatile HttpRouteStatsTracker statsTracker;
+
+    private static final VarHandle STATS_TRACKER_HANDLE;
+
+    static {
+        try {
+            STATS_TRACKER_HANDLE = MethodHandles.lookup().findVarHandle(MethodHandlers.class, "statsTracker", HttpRouteStatsTracker.class);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
 
     MethodHandlers(String path) {
         this.path = path;
@@ -73,19 +86,26 @@ Set<RestRequest.Method> getValidMethods() {
         return methodHandlers.keySet();
     }
 
-    public void addRequestStats(int contentLength) {
-        statsTracker.addRequestStats(contentLength);
-    }
-
-    public void addResponseStats(long contentLength) {
-        statsTracker.addResponseStats(contentLength);
+    public HttpRouteStats getStats() {
+        var tracker = existingStatsTracker();
+        if (tracker == null) {
+            return HttpRouteStats.EMPTY;
+        }
+        return tracker.getStats();
     }
 
-    public void addResponseTime(long timeMillis) {
-        statsTracker.addResponseTime(timeMillis);
+    public HttpRouteStatsTracker statsTracker() {
+        var tracker = existingStatsTracker();
+        if (tracker == null) {
+            var newTracker = new HttpRouteStatsTracker();
+            if ((tracker = (HttpRouteStatsTracker) STATS_TRACKER_HANDLE.compareAndExchange(this, null, newTracker)) == null) {
+                tracker = newTracker;
+            }
+        }
+        return tracker;
     }
 
-    public HttpRouteStats getStats() {
-        return statsTracker.getStats();
+    private HttpRouteStatsTracker existingStatsTracker() {
+        return (HttpRouteStatsTracker) STATS_TRACKER_HANDLE.getAcquire(this);
     }
 }

server/src/main/java/org/elasticsearch/rest/RestController.java

@@ -36,6 +36,7 @@
 import org.elasticsearch.core.TimeValue;
 import org.elasticsearch.http.HttpHeadersValidationException;
 import org.elasticsearch.http.HttpRouteStats;
+import org.elasticsearch.http.HttpRouteStatsTracker;
 import org.elasticsearch.http.HttpServerTransport;
 import org.elasticsearch.indices.breaker.CircuitBreakerService;
 import org.elasticsearch.rest.RestHandler.Route;
@@ -879,7 +880,7 @@ public void sendResponse(RestResponse response) {
     private static final class ResourceHandlingHttpChannel extends DelegatingRestChannel {
         private final CircuitBreakerService circuitBreakerService;
         private final int contentLength;
-        private final MethodHandlers methodHandlers;
+        private final HttpRouteStatsTracker statsTracker;
         private final long startTime;
         private final AtomicBoolean closed = new AtomicBoolean();
 
@@ -892,7 +893,7 @@ private static final class ResourceHandlingHttpChannel extends DelegatingRestCha
             super(delegate);
             this.circuitBreakerService = circuitBreakerService;
             this.contentLength = contentLength;
-            this.methodHandlers = methodHandlers;
+            this.statsTracker = methodHandlers.statsTracker();
             this.startTime = rawRelativeTimeInMillis();
         }
 
@@ -901,12 +902,12 @@ public void sendResponse(RestResponse response) {
             boolean success = false;
             try {
                 close();
-                methodHandlers.addRequestStats(contentLength);
-                methodHandlers.addResponseTime(rawRelativeTimeInMillis() - startTime);
+                statsTracker.addRequestStats(contentLength);
+                statsTracker.addResponseTime(rawRelativeTimeInMillis() - startTime);
                 if (response.isChunked() == false) {
-                    methodHandlers.addResponseStats(response.content().length());
+                    statsTracker.addResponseStats(response.content().length());
                 } else {
-                    final var responseLengthRecorder = new ResponseLengthRecorder(methodHandlers);
+                    final var responseLengthRecorder = new ResponseLengthRecorder(statsTracker);
                     final var headers = response.getHeaders();
                     response = RestResponse.chunked(
                         response.status(),
@@ -941,23 +942,23 @@ private void close() {
         }
     }
 
-    private static class ResponseLengthRecorder extends AtomicReference<MethodHandlers> implements Releasable {
+    private static class ResponseLengthRecorder extends AtomicReference<HttpRouteStatsTracker> implements Releasable {
         private long responseLength;
 
-        private ResponseLengthRecorder(MethodHandlers methodHandlers) {
-            super(methodHandlers);
+        private ResponseLengthRecorder(HttpRouteStatsTracker routeStatsTracker) {
+            super(routeStatsTracker);
         }
 
         @Override
         public void close() {
             // closed just before sending the last chunk, and also when the whole RestResponse is closed since the client might abort the
             // connection before we send the last chunk, in which case we won't have recorded the response in the
             // stats yet; thus we need run-once semantics here:
-            final var methodHandlers = getAndSet(null);
-            if (methodHandlers != null) {
+            final var routeStatsTracker = getAndSet(null);
+            if (routeStatsTracker != null) {
                 // if we started sending chunks then we're closed on the transport worker, no need for sync
                 assert responseLength == 0L || Transports.assertTransportThread();
-                methodHandlers.addResponseStats(responseLength);
+                routeStatsTracker.addResponseStats(responseLength);
             }
         }