feat(http): Add Provider per implementation to limit reflection (#10870)

feat(http): Add Provider per implementation to limit reflection

Co-authored-by: bruce.bujon <bruce.bujon@datadoghq.com>

Author: PerfectSlayer

components/http/http-api/src/main/java/datadog/http/client/HttpClient.java

@@ -41,7 +41,7 @@ public interface HttpClient {
    * @return a new http client builder
    */
   static Builder newBuilder() {
-    return HttpProviders.newClientBuilder();
+    return HttpProviders.get().newClientBuilder();
   }
 
   /** Builder for constructing {@link HttpClient} instances. */

components/http/http-api/src/main/java/datadog/http/client/HttpProvider.java

@@ -0,0 +1,28 @@
+package datadog.http.client;
+
+import java.net.URI;
+import java.nio.ByteBuffer;
+import java.util.List;
+
+/** Factory class providing the various HTTP client class implementations. */
+public abstract class HttpProvider {
+  public abstract HttpClient.Builder newClientBuilder();
+
+  public abstract HttpRequest.Builder newRequestBuilder();
+
+  public abstract HttpUrl.Builder newUrlBuilder();
+
+  public abstract HttpUrl httpUrlParse(String url);
+
+  public abstract HttpUrl httpUrlFrom(URI uri);
+
+  public abstract HttpRequestBody requestBodyOfString(String content);
+
+  public abstract HttpRequestBody requestBodyOfBytes(byte[] bytes);
+
+  public abstract HttpRequestBody requestBodyOfByteBuffers(List<ByteBuffer> buffers);
+
+  public abstract HttpRequestBody requestBodyGzip(HttpRequestBody body);
+
+  public abstract HttpRequestBody.MultipartBuilder requestBodyMultipart();
+}

components/http/http-api/src/main/java/datadog/http/client/HttpProviders.java

@@ -1,48 +1,29 @@
 package datadog.http.client;
 
-import static java.util.Objects.requireNonNull;
-
 import de.thetaphi.forbiddenapis.SuppressForbidden;
-import edu.umd.cs.findbugs.annotations.NonNull;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.net.URI;
-import java.nio.ByteBuffer;
-import java.util.List;
 
 /**
- * Factory class providing HTTP client implementations with automatic fallback support.
- *
- * <p>This class acts as a provider abstraction layer that dynamically discovers and instantiates
- * HTTP client implementations at runtime using reflection. It supports two modes of operation: a
- * default mode using JDK-based HTTP clients and a compatibility mode using OkHttp-based clients.
+ * Static factory class for obtaining HTTP provider implementations.
  *
- * <p>The provider uses lazy initialization and caching of reflection metadata (constructors and
- * methods) to minimize performance overhead. All cached references are stored in volatile fields to
- * ensure thread-safe access in concurrent environments.
+ * <p>This class provides a singleton access point to an {@link HttpProvider} instance, which serves
+ * as a factory for creating HTTP client components such as clients, requests, URLs, and request
+ * bodies.
  *
- * <p>When a component is requested (e.g., client builder, request builder, URL parser), the class
- * attempts to locate the appropriate implementation by searching for specific class names in the
- * classpath. If the default implementation is unavailable or if compatibility mode is enabled, it
- * falls back to alternative implementations.
+ * <p>The provider selection follows a hierarchical fallback strategy: - First attempts to load the
+ * JDK-based HTTP provider implementation - Falls back to the OkHttp-based provider if the JDK
+ * version is not available or incompatible - Can be forced into compatibility mode to skip the JDK
+ * provider and use OkHttp directly
  *
- * <p>Thread Safety: This class is thread-safe. The volatile fields ensure visibility of cached
- * reflection metadata across threads, and the lazy initialization pattern is safe for concurrent
- * access.
+ * <p>The selected provider is cached after the first access for performance. This class is
+ * thread-safe and all methods can be safely called from multiple threads.
  */
 public final class HttpProviders {
+  private static final String JDK_HTTP_PROVIDER_CLASS_NAME =
+      "datadog.http.client.jdk.JdkHttpProvider";
+  private static final String OKHTTP_PROVIDER_CLASS_NAME =
+      "datadog.http.client.okhttp.OkHttpProvider";
   private static volatile boolean compatibilityMode = false;
-
-  private static volatile Constructor<?> HTTP_CLIENT_BUILDER_CONSTRUCTOR;
-  private static volatile Constructor<?> HTTP_REQUEST_BUILDER_CONSTRUCTOR;
-  private static volatile Constructor<?> HTTP_URL_BUILDER_CONSTRUCTOR;
-  private static volatile Method HTTP_URL_PARSE_METHOD;
-  private static volatile Method HTTP_URL_FROM_METHOD;
-  private static volatile Method HTTP_REQUEST_BODY_OF_STRING_METHOD;
-  private static volatile Method HTTP_REQUEST_BODY_OF_BYTES_METHOD;
-  private static volatile Method HTTP_REQUEST_BODY_OF_BYTE_BUFFERS_METHOD;
-  private static volatile Method HTTP_REQUEST_BODY_GZIP_METHOD;
-  private static volatile Constructor<?> HTTP_MULTIPART_BUILDER_CONSTRUCTOR;
+  private static HttpProvider provider;
 
   private HttpProviders() {}
 
@@ -52,224 +33,42 @@ public static void forceCompatClient() {
       return;
     }
     compatibilityMode = true;
-    // Clear all references to make sure to reload them
-    HTTP_CLIENT_BUILDER_CONSTRUCTOR = null;
-    HTTP_REQUEST_BUILDER_CONSTRUCTOR = null;
-    HTTP_URL_BUILDER_CONSTRUCTOR = null;
-    HTTP_URL_PARSE_METHOD = null;
-    HTTP_URL_FROM_METHOD = null;
-    HTTP_REQUEST_BODY_OF_STRING_METHOD = null;
-    HTTP_REQUEST_BODY_OF_BYTES_METHOD = null;
-    HTTP_REQUEST_BODY_OF_BYTE_BUFFERS_METHOD = null;
-    HTTP_REQUEST_BODY_GZIP_METHOD = null;
-    HTTP_MULTIPART_BUILDER_CONSTRUCTOR = null;
-  }
-
-  static HttpClient.Builder newClientBuilder() {
-    if (HTTP_CLIENT_BUILDER_CONSTRUCTOR == null) {
-      HTTP_CLIENT_BUILDER_CONSTRUCTOR =
-          findConstructor(
-              "datadog.http.client.jdk.JdkHttpClient$Builder",
-              "datadog.http.client.okhttp.OkHttpClient$Builder");
-    }
-    try {
-      return (HttpClient.Builder) HTTP_CLIENT_BUILDER_CONSTRUCTOR.newInstance();
-    } catch (ReflectiveOperationException e) {
-      throw new RuntimeException("Failed to call constructor", e);
-    }
-  }
-
-  static HttpRequest.Builder newRequestBuilder() {
-    if (HTTP_REQUEST_BUILDER_CONSTRUCTOR == null) {
-      HTTP_REQUEST_BUILDER_CONSTRUCTOR =
-          findConstructor(
-              "datadog.http.client.jdk.JdkHttpRequest$Builder",
-              "datadog.http.client.okhttp.OkHttpRequest$Builder");
-    }
-    try {
-      return (HttpRequest.Builder) HTTP_REQUEST_BUILDER_CONSTRUCTOR.newInstance();
-    } catch (ReflectiveOperationException e) {
-      throw new RuntimeException("Failed to call constructor", e);
-    }
-  }
-
-  static HttpUrl.Builder newUrlBuilder() {
-    if (HTTP_URL_BUILDER_CONSTRUCTOR == null) {
-      HTTP_URL_BUILDER_CONSTRUCTOR =
-          findConstructor(
-              "datadog.http.client.jdk.JdkHttpUrl$Builder",
-              "datadog.http.client.okhttp.OkHttpUrl$Builder");
-    }
-    try {
-      return (HttpUrl.Builder) HTTP_URL_BUILDER_CONSTRUCTOR.newInstance();
-    } catch (ReflectiveOperationException e) {
-      throw new RuntimeException("Failed to call constructor", e);
-    }
-  }
-
-  static HttpUrl httpUrlParse(String url) {
-    if (HTTP_URL_PARSE_METHOD == null) {
-      HTTP_URL_PARSE_METHOD =
-          findMethod(
-              "datadog.http.client.jdk.JdkHttpUrl",
-              "datadog.http.client.okhttp.OkHttpUrl",
-              "parse",
-              String.class);
-    }
-    try {
-      return (HttpUrl) HTTP_URL_PARSE_METHOD.invoke(null, url);
-    } catch (ReflectiveOperationException e) {
-      if (e.getCause() instanceof IllegalArgumentException) {
-        throw (IllegalArgumentException) e.getCause();
-      }
-      throw new RuntimeException("Failed to call parse method", e);
-    }
-  }
-
-  static HttpUrl httpUrlFrom(URI uri) {
-    if (HTTP_URL_FROM_METHOD == null) {
-      HTTP_URL_FROM_METHOD =
-          findMethod(
-              "datadog.http.client.jdk.JdkHttpUrl",
-              "datadog.http.client.okhttp.OkHttpUrl",
-              "from",
-              URI.class);
-    }
-    try {
-      return (HttpUrl) HTTP_URL_FROM_METHOD.invoke(null, uri);
-    } catch (ReflectiveOperationException e) {
-      throw new RuntimeException("Failed to call from method", e);
-    }
-  }
-
-  static HttpRequestBody requestBodyOfString(String content) {
-    requireNonNull(content, "content");
-    if (HTTP_REQUEST_BODY_OF_STRING_METHOD == null) {
-      HTTP_REQUEST_BODY_OF_STRING_METHOD =
-          findMethod(
-              "datadog.http.client.jdk.JdkHttpRequestBody",
-              "datadog.http.client.okhttp.OkHttpRequestBody",
-              "ofString",
-              String.class);
-    }
-    try {
-      return (HttpRequestBody) HTTP_REQUEST_BODY_OF_STRING_METHOD.invoke(null, content);
-    } catch (ReflectiveOperationException e) {
-      throw new RuntimeException("Failed to call ofString method", e);
-    }
-  }
-
-  static HttpRequestBody requestBodyOfBytes(byte[] bytes) {
-    requireNonNull(bytes, "bytes");
-    if (HTTP_REQUEST_BODY_OF_BYTES_METHOD == null) {
-      HTTP_REQUEST_BODY_OF_BYTES_METHOD =
-          findMethod(
-              "datadog.http.client.jdk.JdkHttpRequestBody",
-              "datadog.http.client.okhttp.OkHttpRequestBody",
-              "ofBytes",
-              byte[].class);
-    }
-    try {
-      return (HttpRequestBody) HTTP_REQUEST_BODY_OF_BYTES_METHOD.invoke(null, (Object) bytes);
-    } catch (ReflectiveOperationException e) {
-      throw new RuntimeException("Failed to call ofBytes method", e);
-    }
-  }
-
-  static HttpRequestBody requestBodyOfByteBuffers(List<ByteBuffer> buffers) {
-    requireNonNull(buffers, "buffers");
-    if (HTTP_REQUEST_BODY_OF_BYTE_BUFFERS_METHOD == null) {
-      HTTP_REQUEST_BODY_OF_BYTE_BUFFERS_METHOD =
-          findMethod(
-              "datadog.http.client.jdk.JdkHttpRequestBody",
-              "datadog.http.client.okhttp.OkHttpRequestBody",
-              "ofByteBuffers",
-              List.class);
-    }
-    try {
-      return (HttpRequestBody) HTTP_REQUEST_BODY_OF_BYTE_BUFFERS_METHOD.invoke(null, buffers);
-    } catch (ReflectiveOperationException e) {
-      throw new RuntimeException("Failed to call ofByteBuffers method", e);
-    }
-  }
-
-  static HttpRequestBody requestBodyGzip(HttpRequestBody body) {
-    requireNonNull(body, "body");
-    if (HTTP_REQUEST_BODY_GZIP_METHOD == null) {
-      HTTP_REQUEST_BODY_GZIP_METHOD =
-          findMethod(
-              "datadog.http.client.jdk.JdkHttpRequestBody",
-              "datadog.http.client.okhttp.OkHttpRequestBody",
-              "ofGzip",
-              HttpRequestBody.class);
-    }
-    try {
-      return (HttpRequestBody) HTTP_REQUEST_BODY_GZIP_METHOD.invoke(null, body);
-    } catch (ReflectiveOperationException e) {
-      throw new RuntimeException("Failed to call ofGzip method", e);
-    }
-  }
-
-  static HttpRequestBody.MultipartBuilder requestBodyMultipart() {
-    if (HTTP_MULTIPART_BUILDER_CONSTRUCTOR == null) {
-      HTTP_MULTIPART_BUILDER_CONSTRUCTOR =
-          findConstructor(
-              "datadog.http.client.jdk.JdkHttpRequestBody$MultipartBuilder",
-              "datadog.http.client.okhttp.OkHttpRequestBody$MultipartBuilder");
-    }
-    try {
-      return (HttpRequestBody.MultipartBuilder) HTTP_MULTIPART_BUILDER_CONSTRUCTOR.newInstance();
-    } catch (ReflectiveOperationException e) {
-      throw new RuntimeException("Failed to call multipart builder constructor", e);
-    }
+    provider = null;
   }
 
-  private static Method findMethod(
-      String defaultClientClass,
-      String compatClientClass,
-      String name,
-      Class<?>... parameterTypes) {
-    Class<?> clientClass = findClientClass(defaultClientClass, compatClientClass);
-    try {
-      return clientClass.getMethod(name, parameterTypes);
-    } catch (NoSuchMethodException e) {
-      throw new RuntimeException("Failed to find " + name + " method", e);
-    }
-  }
-
-  private static Constructor<?> findConstructor(
-      String defaultClientClass, String compatClientClass) {
-    Class<?> clientClass = findClientClass(defaultClientClass, compatClientClass);
-    try {
-      return clientClass.getConstructor();
-    } catch (NoSuchMethodException e) {
-      throw new RuntimeException("Failed to find constructor", e);
+  public static HttpProvider get() {
+    if (provider == null) {
+      provider = findProvider();
     }
+    return provider;
   }
 
   @SuppressForbidden // Class#forName(String) used to dynamically load the http API implementation
-  @NonNull
-  private static Class<?> findClientClass(String defaultClientClass, String compatClientClass) {
+  private static HttpProvider findProvider() {
     Class<?> clazz = null;
     // Load the default client class
     if (!compatibilityMode) {
       try {
-        clazz = Class.forName(defaultClientClass);
+        clazz = Class.forName(JDK_HTTP_PROVIDER_CLASS_NAME);
       } catch (ClassNotFoundException | UnsupportedClassVersionError ignored) {
         compatibilityMode = true;
       }
     }
     // If not loaded, load the compat client class
     if (clazz == null) {
       try {
-        clazz = Class.forName(compatClientClass);
+        clazz = Class.forName(OKHTTP_PROVIDER_CLASS_NAME);
       } catch (ClassNotFoundException ignored) {
       }
     }
     // If no class loaded, raise the illegal state
     if (clazz == null) {
       throw new IllegalStateException("No http client implementation found");
     }
-    return clazz;
+    try {
+      return (HttpProvider) clazz.getDeclaredConstructor().newInstance();
+    } catch (ReflectiveOperationException e) {
+      throw new IllegalStateException("No http client implementation found", e);
+    }
   }
 }

components/http/http-api/src/main/java/datadog/http/client/HttpRequest.java

@@ -57,7 +57,7 @@ public interface HttpRequest {
    * @return a new builder
    */
   static Builder newBuilder() {
-    return HttpProviders.newRequestBuilder();
+    return HttpProviders.get().newRequestBuilder();
   }
 
   /** Builder for constructing {@link HttpRequest} instances. */