fix(tracing): stop 'Unmatched response message' logs for non-stream IO

- Previously only StreamMessageConsumer was treated as "sending". With
WebSocket and other non-stream transports, sentRequests stayed empty, so
every incoming response looked unmatched, emitted a warning, and
produced no trace.
- Now any consumer that is not a RemoteEndpoint is treated as "sending",
ensuring sentRequests is populated regardless of transport and responses
are matched correctly.
- Removed the "Unknown MessageConsumer type" branch to avoid
misclassification and improve compatibility with custom/non-stream
transports.

Author: sebthom

org.eclipse.lsp4j.jsonrpc/src/main/java/org/eclipse/lsp4j/jsonrpc/TracingMessageConsumer.java

@@ -12,7 +12,6 @@
 package org.eclipse.lsp4j.jsonrpc;
 
 import org.eclipse.lsp4j.jsonrpc.json.MessageJsonHandler;
-import org.eclipse.lsp4j.jsonrpc.json.StreamMessageConsumer;
 import org.eclipse.lsp4j.jsonrpc.messages.Message;
 import org.eclipse.lsp4j.jsonrpc.messages.NotificationMessage;
 import org.eclipse.lsp4j.jsonrpc.messages.RequestMessage;
@@ -102,13 +101,12 @@ public void consume(Message message) throws MessageIssueException, JsonRpcExcept
 		final String date = dateTimeFormatter.format(now);
 		final String logString;
 
-		if (messageConsumer instanceof StreamMessageConsumer) {
-			logString = consumeMessageSending(message, now, date);
-		} else if (messageConsumer instanceof RemoteEndpoint) {
+		if (messageConsumer instanceof RemoteEndpoint) {
 			logString = consumeMessageReceiving(message, now, date);
 		} else {
-			LOG.log(WARNING, String.format("Unknown MessageConsumer type: %s", messageConsumer));
-			logString = null;
+			// Treat any non-RemoteEndpoint consumer as an outgoing transport (sending),
+			// so tracing works for WebSocket and other non-stream consumers as well.
+			logString = consumeMessageSending(message, now, date);
 		}
 
 		if (logString != null) {

org.eclipse.lsp4j.jsonrpc/src/test/java/org/eclipse/lsp4j/jsonrpc/test/TracingMessageConsumerTest.java

@@ -33,7 +33,7 @@
 import java.util.concurrent.CompletableFuture;
 
 import static java.util.Collections.emptyMap;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.*;
 
 public class TracingMessageConsumerTest {
 	private static final RemoteEndpoint TEST_REMOTE_ENDPOINT = new EmptyRemoteEndpoint();
@@ -299,6 +299,72 @@ public void testSendingNotificationWithCustomAdapter() {
 
 		assertEquals(expectedTrace, actualTrace);
 	}
+
+	@Test
+	public void testUnmatchedResponseWhenOutgoingIsNotStreamConsumer() {
+		// Simulate an outgoing transport that is not StreamMessageConsumer (e.g., websocket)
+		var outgoingTrace = new StringWriter();
+		var outgoingPrintWriter = new PrintWriter(outgoingTrace);
+
+		var incomingTrace = new StringWriter();
+		var incomingPrintWriter = new PrintWriter(incomingTrace);
+
+		var sentRequests = new HashMap<String, RequestMetadata>();
+		var receivedRequests = new HashMap<String, RequestMetadata>();
+
+		// Wrap a non-stream consumer so TracingMessageConsumer does not treat it as "sending"
+		var outgoingTracing = new TracingMessageConsumer(new EmptyMessageConsumer(), sentRequests, receivedRequests, outgoingPrintWriter, TEST_CLOCK_1, Locale.US);
+
+		// Send a request (this will NOT populate sentRequests because consumer is not StreamMessageConsumer)
+		var req = new RequestMessage();
+		req.setId("1");
+		req.setMethod("foo");
+		outgoingTracing.consume(req);
+
+		// Prepare to capture warnings from TracingMessageConsumer
+		var logger = java.util.logging.Logger.getLogger(TracingMessageConsumer.class.getName());
+		var warnings = new java.util.ArrayList<String>();
+		var handler = new java.util.logging.Handler() {
+			@Override
+			public void publish(java.util.logging.LogRecord record) {
+				if (record.getLevel() == java.util.logging.Level.WARNING)
+					warnings.add(record.getMessage());
+			}
+
+			@Override
+			public void flush() {
+			}
+
+			@Override
+			public void close() throws SecurityException {
+			}
+		};
+		logger.addHandler(handler);
+		try {
+			// Now receive a response on the RemoteEndpoint path. Expected behavior (desired):
+			// no warnings and a proper response trace even when the outgoing transport
+			// is not a StreamMessageConsumer (e.g., websockets).
+			var incomingTracing = new TracingMessageConsumer(TEST_REMOTE_ENDPOINT, sentRequests, receivedRequests, incomingPrintWriter, TEST_CLOCK_2, Locale.US);
+
+			var resp = new ResponseMessage();
+			resp.setId("1");
+			resp.setResult("ok");
+			incomingTracing.consume(resp);
+
+			// Assert NO warning and a proper trace line for the response
+			boolean sawUnmatched = warnings.stream().anyMatch(m -> m.contains("Unmatched response message"));
+			assertFalse("Did not expect unmatched response warning", sawUnmatched);
+			String expectedTrace = "" +
+					"[Trace - 06:07:30 PM] Received response 'foo - (1)' in 100ms\n" +
+					"Result: \"ok\"\n" +
+					"Error: null\n" +
+					"\n" +
+					"\n";
+			assertEquals(expectedTrace, incomingTrace.toString());
+		} finally {
+			logger.removeHandler(handler);
+		}
+	}
 }
 
 class EmptyRemoteEndpoint extends RemoteEndpoint {