fix(java): stop logging the legacy 'connect' probe failure as a warning

CopilotClient probes the 'connect' RPC and falls back to 'ping' when the server does not implement it. JsonRpcClient.invoke logged every failed request at WARNING with a stack trace, so this fully recovered probe printed a scary 'Unhandled method connect' trace on every startup under the JUL default console handler.

Give invoke an internal overload that takes the level used for failures and have the protocol-negotiation probe pass FINE. Unexpected failures still log at WARNING.

Fixes #2291.

Author: Zhangyi Yuan

java/src/main/java/com/github/copilot/CopilotClient.java

@@ -318,8 +318,10 @@ private void verifyProtocolVersion(Connection connection) throws Exception {
             if (this.options.getOnGitHubTelemetry() != null) {
                 connectParams.put("enableGitHubTelemetryForwarding", true);
             }
-            var connectResponse = connection.rpc.invoke("connect", connectParams, ConnectResult.class).get(30,
-                    TimeUnit.SECONDS);
+            // Legacy servers reject 'connect' and we fall back to 'ping' below, so a
+            // failure here is expected rather than warning-worthy.
+            var connectResponse = connection.rpc.invoke("connect", connectParams, ConnectResult.class, Level.FINE)
+                    .get(30, TimeUnit.SECONDS);
             serverVersion = connectResponse.protocolVersion() != null
                     ? connectResponse.protocolVersion().intValue()
                     : null;

java/src/main/java/com/github/copilot/JsonRpcClient.java

@@ -105,6 +105,20 @@ public void registerMethodHandler(String method, BiConsumer<String, JsonNode> ha
      * Sends a JSON-RPC request and waits for the response.
      */
     public <T> CompletableFuture<T> invoke(String method, Object params, Class<T> responseType) {
+        return invoke(method, params, responseType, Level.WARNING);
+    }
+
+    /**
+     * Sends a JSON-RPC request and waits for the response, logging failures at the
+     * given level.
+     *
+     * <p>
+     * Callers that treat a failed response as an expected outcome (for example
+     * probing for a method that older servers do not implement) should pass a level
+     * below {@link Level#WARNING} so the recovered failure is not surfaced to users
+     * as a warning with a stack trace.
+     */
+    <T> CompletableFuture<T> invoke(String method, Object params, Class<T> responseType, Level failureLevel) {
         long timingNanos = System.nanoTime();
         long id = requestIdCounter.incrementAndGet();
         var future = new CompletableFuture<JsonNode>();
@@ -138,7 +152,7 @@ public <T> CompletableFuture<T> invoke(String method, Object params, Class<T> re
                 throw new CompletionException(e);
             }
         }).exceptionally(ex -> {
-            LoggingHelpers.logTiming(LOG, Level.WARNING, ex,
+            LoggingHelpers.logTiming(LOG, failureLevel, ex,
                     "JsonRpc.invoke JSON-RPC request finished. Elapsed={Elapsed}, Method=" + method + ", RequestId="
                             + id + ", Status=Failed",
                     timingNanos);

java/src/test/java/com/github/copilot/JsonRpcClientTest.java

@@ -12,11 +12,18 @@
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.nio.charset.StandardCharsets;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
 
 import org.junit.jupiter.api.Test;
 
@@ -454,4 +461,65 @@ void testCloseWithPendingRequests() throws Exception {
         pair.serverSide.close();
         pair.serverSocket.close();
     }
+
+    // ---- invoke() failure log level ----
+
+    private static final class RecordingLogHandler extends Handler {
+
+        private final List<LogRecord> records = new CopyOnWriteArrayList<>();
+
+        @Override
+        public void publish(LogRecord record) {
+            records.add(record);
+        }
+
+        @Override
+        public void flush() {
+        }
+
+        @Override
+        public void close() {
+        }
+    }
+
+    /**
+     * Runs an invocation that the server rejects and returns everything the
+     * {@link JsonRpcClient} logger emitted while it ran.
+     */
+    private List<LogRecord> captureLogsForFailedInvoke(Function<JsonRpcClient, CompletableFuture<?>> invoker)
+            throws Exception {
+        var logger = Logger.getLogger(JsonRpcClient.class.getName());
+        var handler = new RecordingLogHandler();
+        logger.addHandler(handler);
+        try (var pair = createSocketPair()) {
+            CompletableFuture<?> future = invoker.apply(pair.client);
+
+            String request = readRpcMessage(pair.serverSide.getInputStream());
+            long id = MAPPER.readTree(request).get("id").asLong();
+            writeRpcMessage(pair.serverSide.getOutputStream(), "{\"jsonrpc\":\"2.0\",\"id\":" + id
+                    + ",\"error\":{\"code\":-32601,\"message\":\"Unhandled method connect\"}}");
+
+            assertThrows(ExecutionException.class, () -> future.get(5, TimeUnit.SECONDS));
+            return handler.records;
+        } finally {
+            logger.removeHandler(handler);
+        }
+    }
+
+    @Test
+    void testInvokeLogsFailureAtWarningByDefault() throws Exception {
+        var records = captureLogsForFailedInvoke(client -> client.invoke("connect", Map.of(), JsonNode.class));
+
+        assertTrue(records.stream().anyMatch(r -> r.getLevel() == Level.WARNING),
+                "Unexpected RPC failures should still be logged at WARNING");
+    }
+
+    @Test
+    void testInvokeHonorsCustomFailureLogLevel() throws Exception {
+        var records = captureLogsForFailedInvoke(
+                client -> client.invoke("connect", Map.of(), JsonNode.class, Level.FINE));
+
+        assertTrue(records.stream().noneMatch(r -> r.getLevel().intValue() >= Level.WARNING.intValue()),
+                "A failure the caller expects and recovers from must not be logged at WARNING");
+    }
 }