fix: Switch DefaultHttpAdapter from OkHttp to HttpURLConnection

Replace OkHttp transport with java.net.HttpURLConnection; remove okhttp
and logging-interceptor compile dependencies. Preserve debug logging
behind RECURLY_INSECURE + RECURLY_DEBUG using System.out.println.

Fix 411 errors on POST/PUT with null body by sending Content-Length: 0,
matching OkHttp prior behavior. Add contract tests for this case.

Update the implementation guide to use OkHttp as the example adapter
instead of java.net.http.HttpClient.

Co-Authored-By: Claude <noreply@anthropic.com>

feat: Add gzip response decompression to DefaultHttpAdapter

DefaultHttpAdapter now sets Accept-Encoding: gzip on outgoing requests
(unless the caller already set one) and transparently decompresses
gzip-encoded response and error bodies via GZIPInputStream, matching
the behavior OkHttp provided automatically before the HttpURLConnection
migration. content-encoding and content-length are stripped from the
returned headers once decompressed since they no longer describe the
decompressed body.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: douglasmiller

docs/http-adapter-implementation-guide.md

@@ -161,53 +161,78 @@ adapter and adjust to your SLA requirements.
 
 ---
 
-## Minimal example
+## OkHttp example
+
+Add the OkHttp dependency to your project:
+
+```xml
+<dependency>
+    <groupId>com.squareup.okhttp3</groupId>
+    <artifactId>okhttp</artifactId>
+    <version>4.12.0</version>
+</dependency>
+```
 
 ```java
 import com.recurly.v3.http.HttpAdapter;
 import com.recurly.v3.http.HttpResponse;
 
 import java.io.IOException;
-import java.net.URI;
-import java.net.http.HttpClient;
-import java.net.http.HttpRequest;
-import java.net.http.HttpRequest.BodyPublishers;
-import java.time.Duration;
 import java.util.HashMap;
 import java.util.Map;
-
-public class JavaNetHttpAdapter implements HttpAdapter {
-
-    private final HttpClient client = HttpClient.newBuilder()
-            .connectTimeout(Duration.ofSeconds(30))
+import java.util.concurrent.TimeUnit;
+import okhttp3.Headers;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+
+public class OkHttpAdapter implements HttpAdapter {
+
+    private final OkHttpClient client = new OkHttpClient.Builder()
+            .connectTimeout(60, TimeUnit.SECONDS)
+            .readTimeout(60, TimeUnit.SECONDS)
+            .writeTimeout(60, TimeUnit.SECONDS)
             .build();
 
     @Override
     public HttpResponse execute(String method, String url,
                                 Map<String, String> headers, String body) throws IOException {
-        HttpRequest.Builder builder = HttpRequest.newBuilder()
-                .uri(URI.create(url))
-                .method(method, body != null
-                        ? BodyPublishers.ofString(body)
-                        : BodyPublishers.noBody());
+        Request.Builder builder = new Request.Builder().url(url);
 
-        headers.forEach(builder::header);
+        for (Map.Entry<String, String> header : headers.entrySet()) {
+            builder.header(header.getKey(), header.getValue());
+        }
+
+        RequestBody requestBody = body != null
+                ? RequestBody.create(body, MediaType.parse("application/json; charset=utf-8"))
+                : RequestBody.create(new byte[0]);
+
+        switch (method) {
+            case "HEAD":   builder.head();            break;
+            case "GET":    builder.get();             break;
+            case "POST":   builder.post(requestBody); break;
+            case "PUT":    builder.put(requestBody);  break;
+            case "DELETE": builder.delete();          break;
+            default:
+                throw new IllegalArgumentException(method + " is not a valid Recurly HTTP method");
+        }
 
-        try {
-            java.net.http.HttpResponse<byte[]> resp =
-                    client.send(builder.build(), java.net.http.HttpResponse.BodyHandlers.ofByteArray());
+        try (Response response = client.newCall(builder.build()).execute()) {
+            int statusCode = response.code();
 
             Map<String, String> responseHeaders = new HashMap<>();
-            resp.headers().map().forEach((k, vs) -> {
-                if (k != null && !vs.isEmpty()) responseHeaders.put(k, vs.get(0));
-            });
+            Headers okHeaders = response.headers();
+            for (int i = 0; i < okHeaders.size(); i++) {
+                responseHeaders.put(okHeaders.name(i).toLowerCase(), okHeaders.value(i));
+            }
 
-            return new HttpResponse(resp.statusCode(), responseHeaders,
-                    resp.body() != null ? resp.body() : new byte[0]);
+            ResponseBody responseBody = response.body();
+            byte[] responseBodyBytes = responseBody != null ? responseBody.bytes() : new byte[0];
 
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            throw new IOException("HTTP request interrupted", e);
+            return new HttpResponse(statusCode, responseHeaders, responseBodyBytes);
         }
     }
 }
@@ -274,4 +299,4 @@ public class FakeHttpAdapter implements HttpAdapter {
 }
 ```
 
-See `DefaultHttpAdapter` for the complete production reference implementation.
+See `DefaultHttpAdapter` for the `HttpURLConnection`-based reference implementation.

pom.xml

@@ -61,7 +61,6 @@
         <java.version>1.8</java.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-        <okhttp3.version>4.12.0</okhttp3.version>
         <wiremock.version>3.13.2</wiremock.version>
         <surefire.version>3.5.5</surefire.version>
         <jacoco.version>0.8.13</jacoco.version>
@@ -240,16 +239,6 @@
             <artifactId>gson</artifactId>
             <version>2.13.1</version>
         </dependency>
-        <dependency>
-            <groupId>com.squareup.okhttp3</groupId>
-            <artifactId>okhttp</artifactId>
-            <version>${okhttp3.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.squareup.okhttp3</groupId>
-            <artifactId>logging-interceptor</artifactId>
-            <version>${okhttp3.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.wiremock</groupId>
             <artifactId>wiremock</artifactId>

src/main/java/com/recurly/v3/Client.java

@@ -10,7 +10,6 @@
 import com.recurly.v3.requests.*;
 import com.recurly.v3.resources.*;
 import com.recurly.v3.queryparams.*;
-import okhttp3.OkHttpClient;
 import java.time.ZonedDateTime;
 
 import java.lang.reflect.Type;

src/main/java/com/recurly/v3/http/DefaultHttpAdapter.java

@@ -1,41 +1,28 @@
 package com.recurly.v3.http;
 
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import okhttp3.Headers;
-import okhttp3.MediaType;
-import okhttp3.OkHttpClient;
-import okhttp3.Request;
-import okhttp3.RequestBody;
-import okhttp3.Response;
-import okhttp3.ResponseBody;
-import okhttp3.logging.HttpLoggingInterceptor;
+import java.util.zip.GZIPInputStream;
 
 public class DefaultHttpAdapter implements HttpAdapter {
   private static final int DEFAULT_TIMEOUT_MS = 60_000;
 
-  private final OkHttpClient httpClient;
+  private final int timeoutMs;
 
   public DefaultHttpAdapter() {
     this(DEFAULT_TIMEOUT_MS);
   }
 
   public DefaultHttpAdapter(final int timeoutMs) {
-    final OkHttpClient.Builder builder =
-        new OkHttpClient.Builder()
-            .connectTimeout(timeoutMs, TimeUnit.MILLISECONDS)
-            .readTimeout(timeoutMs, TimeUnit.MILLISECONDS)
-            .writeTimeout(timeoutMs, TimeUnit.MILLISECONDS);
-
-    if (envEnabled("RECURLY_INSECURE") && envEnabled("RECURLY_DEBUG")) {
-      final HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
-      logging.setLevel(HttpLoggingInterceptor.Level.BASIC);
-      builder.addInterceptor(logging);
-    }
-
-    this.httpClient = builder.build();
+    this.timeoutMs = timeoutMs;
   }
 
   @Override
@@ -45,51 +32,87 @@ public HttpResponse execute(
       final Map<String, String> headers,
       final String body)
       throws IOException {
-    final Request.Builder requestBuilder = new Request.Builder().url(url);
+    final boolean debug = envEnabled("RECURLY_INSECURE") && envEnabled("RECURLY_DEBUG");
+    if (debug) {
+      System.out.println("--> " + method + " " + url);
+    }
+    final long startMs = System.currentTimeMillis();
 
+    final HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
+    connection.setRequestMethod(method);
+    connection.setConnectTimeout(timeoutMs);
+    connection.setReadTimeout(timeoutMs);
+
+    boolean callerSetAcceptEncoding = false;
     for (final Map.Entry<String, String> header : headers.entrySet()) {
-      requestBuilder.header(header.getKey(), header.getValue());
+      connection.setRequestProperty(header.getKey(), header.getValue());
+      if ("Accept-Encoding".equalsIgnoreCase(header.getKey())) {
+        callerSetAcceptEncoding = true;
+      }
+    }
+    if (!callerSetAcceptEncoding) {
+      connection.setRequestProperty("Accept-Encoding", "gzip");
     }
 
-    final RequestBody requestBody =
-        body != null
-            ? RequestBody.create(body, MediaType.parse("application/json; charset=utf-8"))
-            : RequestBody.create(new byte[0]);
-
-    switch (method) {
-      case "HEAD":
-        requestBuilder.head();
-        break;
-      case "GET":
-        requestBuilder.get();
-        break;
-      case "POST":
-        requestBuilder.post(requestBody);
-        break;
-      case "PUT":
-        requestBuilder.put(requestBody);
-        break;
-      case "DELETE":
-        requestBuilder.delete();
-        break;
-      default:
-        throw new IllegalArgumentException(method + " is not a valid Recurly HTTP method");
+    if (body != null || "POST".equals(method) || "PUT".equals(method)) {
+      connection.setDoOutput(true);
+      final byte[] bodyBytes = body != null ? body.getBytes(StandardCharsets.UTF_8) : new byte[0];
+      try (final OutputStream out = connection.getOutputStream()) {
+        out.write(bodyBytes);
+      }
     }
 
-    try (final Response response = httpClient.newCall(requestBuilder.build()).execute()) {
-      final int statusCode = response.code();
+    final int statusCode = connection.getResponseCode();
 
-      final Map<String, String> responseHeaders = new HashMap<>();
-      final Headers okHeaders = response.headers();
-      for (int i = 0; i < okHeaders.size(); i++) {
-        responseHeaders.put(okHeaders.name(i).toLowerCase(), okHeaders.value(i));
+    final Map<String, String> responseHeaders = new HashMap<>();
+    for (final Map.Entry<String, List<String>> entry : connection.getHeaderFields().entrySet()) {
+      final String key = entry.getKey();
+      if (key != null && !entry.getValue().isEmpty()) {
+        responseHeaders.put(key.toLowerCase(), entry.getValue().get(0));
       }
+    }
+
+    final InputStream inputStream;
+    if ("HEAD".equals(method)) {
+      inputStream = null;
+    } else {
+      inputStream = statusCode >= 400 ? connection.getErrorStream() : connection.getInputStream();
+    }
 
-      final ResponseBody responseBody = response.body();
-      final byte[] responseBodyBytes = responseBody != null ? responseBody.bytes() : new byte[0];
+    final String contentEncoding = responseHeaders.get("content-encoding");
+    final boolean gzipEncoded = contentEncoding != null && "gzip".equalsIgnoreCase(contentEncoding.trim());
+
+    final byte[] responseBodyBytes;
+    if (inputStream == null) {
+      responseBodyBytes = new byte[0];
+    } else {
+      try (final InputStream rawStream = inputStream;
+          final InputStream is = gzipEncoded ? new GZIPInputStream(rawStream) : rawStream) {
+        responseBodyBytes = readAllBytes(is);
+      }
+    }
+
+    if (gzipEncoded) {
+      responseHeaders.remove("content-encoding");
+      responseHeaders.remove("content-length");
+    }
+
+    if (debug) {
+      System.out.println(
+          "<-- " + statusCode + " " + url + " (" + (System.currentTimeMillis() - startMs) + "ms)");
+    }
+
+    return new HttpResponse(statusCode, responseHeaders, responseBodyBytes);
+  }
 
-      return new HttpResponse(statusCode, responseHeaders, responseBodyBytes);
+  private static byte[] readAllBytes(final InputStream inputStream) throws IOException {
+    final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+    final byte[] chunk = new byte[8192];
+    int n;
+    while ((n = inputStream.read(chunk)) != -1) {
+      buffer.write(chunk, 0, n);
     }
+    return buffer.toByteArray();
   }
 
   private static boolean envEnabled(final String envVar) {

src/test/java/com/recurly/v3/BaseClientTest.java

@@ -102,6 +102,50 @@ public void testMakeRequestWithoutResource() throws IOException {
     verify(mockAdapter).execute(eq("DELETE"), contains("/resources/resource-id"), any(), isNull());
   }
 
+  @Test
+  public void testBuildHeadersSendsCorrectAuthAcceptAndUserAgent() throws IOException {
+    final HttpAdapter mockAdapter = mock(HttpAdapter.class);
+    when(mockAdapter.execute(any(), any(), any(), any())).thenReturn(jsonResponse(200, "{}"));
+    final ArgumentCaptor<Map<String, String>> headersCaptor = ArgumentCaptor.forClass(Map.class);
+
+    mockClientWith(mockAdapter).getResource("resource-id");
+
+    verify(mockAdapter).execute(any(), any(), headersCaptor.capture(), any());
+    final Map<String, String> headers = headersCaptor.getValue();
+
+    assertEquals(
+        "Basic " + java.util.Base64.getEncoder().encodeToString("apiKey:".getBytes(StandardCharsets.ISO_8859_1)),
+        headers.get("Authorization"));
+    assertEquals("application/vnd.recurly." + Client.API_VERSION, headers.get("Accept"));
+    assertTrue(
+        headers.get("User-Agent").matches("Recurly/\\d+\\.\\d+\\.\\d+(-SNAPSHOT)?;\\s+java\\s+\\d+.*"),
+        "User-Agent header should match the expected format, was: " + headers.get("User-Agent"));
+  }
+
+  @Test
+  public void testWarnIfDeprecatedPrintsWarningWhenHeaderPresent() throws IOException {
+    final HttpAdapter mockAdapter = mock(HttpAdapter.class);
+    final Map<String, String> responseHeaders = new HashMap<>();
+    responseHeaders.put("content-type", "application/json; charset=utf-8");
+    responseHeaders.put("recurly-deprecated", "true");
+    responseHeaders.put("recurly-sunset-date", "2026-01-01");
+    when(mockAdapter.execute(any(), any(), any(), any()))
+        .thenReturn(new HttpResponse(200, responseHeaders, "{}".getBytes(StandardCharsets.UTF_8)));
+
+    final java.io.PrintStream originalOut = System.out;
+    final java.io.ByteArrayOutputStream captured = new java.io.ByteArrayOutputStream();
+    System.setOut(new java.io.PrintStream(captured));
+    try {
+      mockClientWith(mockAdapter).getResource("resource-id");
+    } finally {
+      System.setOut(originalOut);
+    }
+
+    final String output = captured.toString(StandardCharsets.UTF_8.name());
+    assertTrue(output.contains("WARNING"), "Expected a deprecation warning, got: " + output);
+    assertTrue(output.contains("2026-01-01"), "Expected the sunset date in the warning, got: " + output);
+  }
+
   @Test
   public void testMakeRequestWithQueryParams() throws IOException {
     final ZonedDateTime dateTime = ZonedDateTime.now();
@@ -157,6 +201,17 @@ public void testNonJsonError500() throws IOException {
         () -> mockClientWith(mockAdapter).getResource("code-aaron"));
   }
 
+  @Test
+  public void testNonJsonErrorViaRemoveResource() throws IOException {
+    final HttpAdapter mockAdapter = mock(HttpAdapter.class);
+    when(mockAdapter.execute(any(), any(), any(), any()))
+        .thenReturn(htmlResponse(500, "<html>badness</html>"));
+
+    assertThrows(
+        InternalServerException.class,
+        () -> mockClientWith(mockAdapter).removeResource("code-aaron"));
+  }
+
   @Test
   public void testInvalidApiKey() throws IOException {
     final HttpAdapter mockAdapter = mock(HttpAdapter.class);