MCP-3 Support logging from the MCP server

Author: damien-urruty-sonarsource

build.gradle.kts

@@ -62,7 +62,7 @@ license {
 		)
 	)
 	excludes(
-		listOf("**/*.jar", "**/*.png", "**/README")
+		listOf("**/*.jar", "**/*.png", "**/README", "**/logback.xml")
 	)
 	strictCheck = true
 }
@@ -76,6 +76,8 @@ configurations {
 	create("omnisharp")
 }
 
+val mockitoAgent = configurations.create("mockitoAgent")
+
 dependencies {
 	implementation(libs.mcp.server)
 	implementation(libs.sonarlint.java.client.utils)
@@ -84,13 +86,15 @@ dependencies {
 	implementation(libs.commons.langs3)
 	implementation(libs.commons.text)
 	implementation(libs.sslcontext.kickstart)
+	runtimeOnly(libs.logback.classic)
 	testImplementation(platform(libs.junit.bom))
 	testImplementation(libs.junit.jupiter)
 	testImplementation(libs.mockito.core)
 	testImplementation(libs.assertj)
 	testImplementation(libs.awaitility)
 	testImplementation(libs.wiremock)
 	testRuntimeOnly(libs.junit.launcher)
+	mockitoAgent(libs.mockito.core) { isTransitive = false }
 	"sqplugins"(libs.bundles.sonar.analyzers)
 	if (artifactoryUsername.isNotEmpty() && artifactoryPassword.isNotEmpty()) {
 		"sqplugins"(libs.sonar.cfamily)
@@ -179,6 +183,7 @@ tasks {
 		systemProperty("TELEMETRY_DISABLED", "true")
 		systemProperty("sonar.mcp.server.version", project.version)
 		doNotTrackState("Tests should always run")
+		jvmArgs("-javaagent:${mockitoAgent.asPath}")
 	}
 
 	register("preparePlugins") {

gradle/libs.versions.toml

@@ -26,6 +26,7 @@ mcp-server = "0.9.0"
 commons-lang3 = "3.17.0"
 commons-text = "1.13.0"
 sslcontext-kickstart = "9.1.0"
+logback = "1.5.17"
 
 junit = "5.12.2"
 junit-launcher = "1.12.2"
@@ -60,6 +61,9 @@ mcp-server = { module = "io.modelcontextprotocol.sdk:mcp", version.ref = "mcp-se
 commons-langs3 = { module = "org.apache.commons:commons-lang3", version.ref = "commons-lang3" }
 commons-text = { module = "org.apache.commons:commons-text", version.ref = "commons-text" }
 sslcontext-kickstart = { module = "io.github.hakky54:sslcontext-kickstart", version.ref = "sslcontext-kickstart" }
+logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
+
+
 junit-bom = { module = "org.junit:junit-bom", version.ref = "junit" }
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit" }
 junit-launcher = { module = "org.junit.platform:junit-platform-launcher", version.ref = "junit-launcher" }

src/main/java/org/sonar/mcp/SonarMcpServer.java

@@ -71,7 +71,7 @@ public void start() {
       .capabilities(McpSchema.ServerCapabilities.builder().tools(true).logging().build())
       .tools(supportedTools.stream().map(this::toSpec).toArray(McpServerFeatures.SyncToolSpecification[]::new))
       .build();
-
+    LOG.setOutput(syncServer);
     Runtime.getRuntime().addShutdownHook(new Thread(() -> shutdown(syncServer, backendService)));
   }
 
@@ -104,6 +104,7 @@ private static void shutdown(McpSyncServer syncServer, BackendService backendSer
     } catch (Exception e) {
       LOG.error("Error shutting down MCP backend", e);
     }
+    McpLogger.getInstance().setOutput(null);
   }
 
 }

src/main/java/org/sonar/mcp/log/McpLogger.java

@@ -19,6 +19,11 @@
  */
 package org.sonar.mcp.log;
 
+import io.modelcontextprotocol.server.McpSyncServer;
+import io.modelcontextprotocol.spec.McpSchema;
+import jakarta.annotation.Nullable;
+import java.io.PrintWriter;
+import java.io.StringWriter;
 import org.sonarsource.sonarlint.core.rpc.protocol.client.log.LogLevel;
 import org.sonarsource.sonarlint.core.rpc.protocol.client.log.LogParams;
 
@@ -29,7 +34,17 @@ public static McpLogger getInstance() {
     return INSTANCE;
   }
 
+  private McpSyncServer syncServer;
+
+  public void setOutput(@Nullable McpSyncServer syncServer) {
+    this.syncServer = syncServer;
+  }
+
   public void log(LogParams params) {
+    var message = params.getMessage();
+    if (message != null) {
+      log(message, params.getLevel());
+    }
     var stackTrace = params.getStackTrace();
     if (stackTrace != null) {
       log(stackTrace, params.getLevel());
@@ -42,11 +57,32 @@ public void info(String message) {
 
   public void error(String message, Throwable throwable) {
     log(message, LogLevel.ERROR);
-    throwable.printStackTrace();
+    log(stackTraceToString(throwable), LogLevel.ERROR);
+  }
+
+  private void log(String message, LogLevel level) {
+    if (syncServer != null) {
+      // We rely on a deprecated API for now, I opened a discussion in https://github.com/modelcontextprotocol/java-sdk/issues/131
+      try {
+        syncServer.loggingNotification(new McpSchema.LoggingMessageNotification(toMcpLevel(level), "sonar-mcp-server", message));
+      } catch (Exception e) {
+        // we can't do much
+      }
+    }
+  }
+
+  static McpSchema.LoggingLevel toMcpLevel(LogLevel level) {
+    return switch (level) {
+      case ERROR -> McpSchema.LoggingLevel.ERROR;
+      case WARN -> McpSchema.LoggingLevel.WARNING;
+      case INFO -> McpSchema.LoggingLevel.INFO;
+      case DEBUG, TRACE -> McpSchema.LoggingLevel.DEBUG;
+    };
   }
 
-  private static void log(String message, LogLevel level) {
-    // will be properly implemented in SLCORE-1345
-    System.out.println("[" + level.name() + "] " + message);
+  static String stackTraceToString(Throwable t) {
+    var stringWriter = new StringWriter();
+    t.printStackTrace(new PrintWriter(stringWriter));
+    return stringWriter.toString();
   }
 }

src/main/resources/logback.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE configuration>
+
+<configuration>
+  <root level="warn"/>
+  <logger name="org.springframework" level="warn"/>
+  <logger name="org.sonarsource.sonarlint.core.plugin.commons.container.PriorityBeanFactory" level="warn"/>
+  <logger name="nl.altindag.ssl" level="warn"/>
+  <logger name="jetbrains.exodus" level="warn"/>
+  <logger name="org.apache.hc" level="warn"/>
+  <logger name="org.eclipse.lsp4j.jsonrpc" level="error"/>
+  <logger name="org.eclipse.jgit" level="info"/>
+  <logger name="org.sonar.scm.git.blame" level="info"/>
+  <!-- Disable to avoid logs being printed in loop -->
+  <logger name="io.modelcontextprotocol.spec.McpSchema" level="off" />
+  <logger name="io.modelcontextprotocol.client.McpAsyncClient" level="off" />
+  <logger name="io.modelcontextprotocol.spec.McpClientSession" level="off" />
+  <!-- Disable logback's own logs -->
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener" />
+</configuration>

src/test/java/org/sonar/mcp/harness/InMemoryClientTransport.java

@@ -220,9 +220,6 @@ private static void log(String message) {
   }
 
   private static void log(String message, @Nullable Throwable e) {
-    System.out.println(message);
-    if (e != null) {
-      e.printStackTrace();
-    }
+    // no log for now
   }
 }

src/test/java/org/sonar/mcp/harness/SonarMcpServerTestHarness.java

@@ -23,6 +23,7 @@
 import io.modelcontextprotocol.client.McpClient;
 import io.modelcontextprotocol.client.McpSyncClient;
 import io.modelcontextprotocol.server.transport.StdioServerTransportProvider;
+import io.modelcontextprotocol.spec.McpSchema;
 import java.io.IOException;
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;
@@ -90,8 +91,10 @@ public McpSyncClient newClient(Map<String, String> overriddenEnv) {
       var environment = new HashMap<>(DEFAULT_ENV);
       environment.putAll(overriddenEnv);
       new SonarMcpServer(new StdioServerTransportProvider(new ObjectMapper(), clientToServerInputStream, serverToClientOutputStream), environment).start();
-      client = McpClient.sync(new InMemoryClientTransport(serverToClientInputStream, clientToServerOutputStream)).build();
+      client = McpClient.sync(new InMemoryClientTransport(serverToClientInputStream, clientToServerOutputStream))
+        .loggingConsumer(System.out::println).build();
       client.initialize();
+      client.setLoggingLevel(McpSchema.LoggingLevel.CRITICAL);
     } catch (IOException e) {
       throw new RuntimeException(e);
     }

src/test/java/org/sonar/mcp/log/McpLoggerTest.java

@@ -0,0 +1,81 @@
+/*
+ * Sonar MCP Server
+ * Copyright (C) 2025 SonarSource
+ * [email protected]
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02
+ */
+package org.sonar.mcp.log;
+
+import io.modelcontextprotocol.server.McpSyncServer;
+import io.modelcontextprotocol.spec.McpSchema;
+import java.time.Instant;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.sonarsource.sonarlint.core.rpc.protocol.client.log.LogLevel;
+import org.sonarsource.sonarlint.core.rpc.protocol.client.log.LogParams;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+class McpLoggerTest {
+
+  @AfterEach
+  void teardown() {
+    McpLogger.getInstance().setOutput(null);
+  }
+
+  @Test
+  void it_should_convert_the_log_level() {
+    assertThat(McpLogger.toMcpLevel(LogLevel.TRACE)).isEqualTo(McpSchema.LoggingLevel.DEBUG);
+    assertThat(McpLogger.toMcpLevel(LogLevel.DEBUG)).isEqualTo(McpSchema.LoggingLevel.DEBUG);
+    assertThat(McpLogger.toMcpLevel(LogLevel.INFO)).isEqualTo(McpSchema.LoggingLevel.INFO);
+    assertThat(McpLogger.toMcpLevel(LogLevel.WARN)).isEqualTo(McpSchema.LoggingLevel.WARNING);
+    assertThat(McpLogger.toMcpLevel(LogLevel.ERROR)).isEqualTo(McpSchema.LoggingLevel.ERROR);
+  }
+
+  @Test
+  void it_should_send_an_rcp_log_to_the_client() {
+    var logger = McpLogger.getInstance();
+    var mockServer = mock(McpSyncServer.class);
+    logger.setOutput(mockServer);
+
+    logger.log(new LogParams(LogLevel.DEBUG, "Message", null, "stack\ntrace", Instant.now()));
+
+    verify(mockServer).loggingNotification(new McpSchema.LoggingMessageNotification(McpSchema.LoggingLevel.DEBUG, "sonar-mcp-server", "Message"));
+    verify(mockServer).loggingNotification(new McpSchema.LoggingMessageNotification(McpSchema.LoggingLevel.DEBUG, "sonar-mcp-server", "stack\ntrace"));
+  }
+
+  @Test
+  void it_should_send_an_error_log_to_the_client() {
+    var logger = McpLogger.getInstance();
+    var mockServer = mock(McpSyncServer.class);
+    logger.setOutput(mockServer);
+
+    logger.error("Message", new RuntimeException("kaboom"));
+
+    var captor = ArgumentCaptor.forClass(McpSchema.LoggingMessageNotification.class);
+    verify(mockServer, times(2)).loggingNotification(captor.capture());
+    var notifications = captor.getAllValues();
+    assertThat(notifications.getFirst()).isEqualTo(new McpSchema.LoggingMessageNotification(McpSchema.LoggingLevel.ERROR, "sonar-mcp-server", "Message"));
+    assertThat(notifications.get(1).level()).isEqualTo(McpSchema.LoggingLevel.ERROR);
+    assertThat(notifications.get(1).logger()).isEqualTo("sonar-mcp-server");
+    assertThat(notifications.get(1).data()).contains("java.lang.RuntimeException: kaboom\n");
+  }
+
+}