fix: bypass proxy for Runtime API HTTP calls

Use Proxy.NO_PROXY when opening HttpURLConnection to RAPID endpoints.
This prevents customer-configured http.proxyHost from routing internal
Runtime API calls through the proxy, which fails when RAPID is not on a
loopback address (localhost is implicitly exempt in most proxy
implementations).

The hot path (nextInvocation/postInvocationResponse) already bypasses
Java's ProxySelector via the native C++/libcurl NativeClient and is not
affected.

Proxy.NO_PROXY is per-connection scoped, zero impact on customer
handler HTTP calls.

Author: ilyasse benrkia

aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClientImpl.java

@@ -14,6 +14,7 @@
 import java.io.OutputStream;
 import java.net.HttpURLConnection;
 import java.net.MalformedURLException;
+import java.net.Proxy;
 import java.net.URL;
 import java.util.HashMap;
 import java.util.Map;
@@ -175,8 +176,7 @@ void reportLambdaError(String endpoint, LambdaError error, int maxXrayHeaderSize
     private int doPost(String endpoint,
                        Map<String, String> headers,
                        byte[] payload) throws IOException {
-        URL url = createUrl(endpoint);
-        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+        HttpURLConnection conn = createConnection(endpoint);
         conn.setRequestMethod("POST");
         conn.setRequestProperty("Content-Type", DEFAULT_CONTENT_TYPE);
         conn.setRequestProperty("User-Agent", USER_AGENT);
@@ -201,8 +201,7 @@ private int doPost(String endpoint,
     }
 
     private int doGet(String endpoint) throws IOException {
-        URL url = createUrl(endpoint);
-        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+        HttpURLConnection conn = createConnection(endpoint);
         conn.setRequestMethod("GET");
         conn.setRequestProperty("User-Agent", USER_AGENT);
 
@@ -212,6 +211,15 @@ private int doGet(String endpoint) throws IOException {
         return responseCode;
     }
 
+    /**
+     * Opens a direct connection to the given endpoint, bypassing any
+     * customer-configured proxy.
+     */
+    private HttpURLConnection createConnection(String endpoint) throws IOException {
+        URL url = createUrl(endpoint);
+        return (HttpURLConnection) url.openConnection(Proxy.NO_PROXY);
+    }
+
     private URL createUrl(String endpoint) {
         try {
             return new URL(endpoint);

aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeApiClientImplTest.java

@@ -24,6 +24,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.net.InetAddress;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
@@ -533,6 +534,54 @@ public void reportInvocationErrorWithInvocationIdTest() {
         }
     }
 
+    @Test
+    public void connectionBypassesConfiguredProxy() throws Exception {
+        // Bind RAPID mock to a non-loopback IP so Java's ProxySelector doesn't
+        // auto-exempt it. On loopback (127.0.0.1), the JVM skips proxy regardless.
+        MockWebServer nonLoopbackServer = new MockWebServer();
+        InetAddress nonLoopback = InetAddress.getLocalHost();
+        nonLoopbackServer.start(nonLoopback, 0);
+
+        MockWebServer fakeProxy = new MockWebServer();
+        fakeProxy.start();
+        // Enqueue a response so if proxy is used, the test fails fast instead of hanging indefinitely.
+        fakeProxy.enqueue(new MockResponse().setResponseCode(HTTP_ACCEPTED));
+
+        String previousProxyHost = System.getProperty("http.proxyHost");
+        String previousProxyPort = System.getProperty("http.proxyPort");
+
+        System.setProperty("http.proxyHost", fakeProxy.getHostName());
+        System.setProperty("http.proxyPort", String.valueOf(fakeProxy.getPort()));
+
+        try {
+            MockResponse mockResponse = new MockResponse();
+            mockResponse.setResponseCode(HTTP_ACCEPTED);
+            nonLoopbackServer.enqueue(mockResponse);
+
+            String endpoint = "http://" + nonLoopback.getHostAddress() + ":" + nonLoopbackServer.getPort();
+            LambdaError lambdaError = new LambdaError(errorRequest, RapidErrorType.AfterRestoreError);
+            lambdaRuntimeApiClientImpl.reportLambdaError(endpoint, lambdaError, 1024 * 1024, null);
+
+            // Request arrived at RAPID mock directly
+            assertEquals(1, nonLoopbackServer.getRequestCount());
+            // Nothing went to the fake proxy
+            assertEquals(0, fakeProxy.getRequestCount());
+        } finally {
+            if (previousProxyHost != null) {
+                System.setProperty("http.proxyHost", previousProxyHost);
+            } else {
+                System.clearProperty("http.proxyHost");
+            }
+            if (previousProxyPort != null) {
+                System.setProperty("http.proxyPort", previousProxyPort);
+            } else {
+                System.clearProperty("http.proxyPort");
+            }
+            nonLoopbackServer.shutdown();
+            fakeProxy.shutdown();
+        }
+    }
+
     private String getHostnamePort() {
         return mockWebServer.getHostName() + ":" + mockWebServer.getPort();
     }