Add McpLogger/McpLoggerProvider for server logs

src/ModelContextProtocol/Client/McpClientExtensions.cs

@@ -13,6 +13,19 @@ namespace ModelContextProtocol.Client;
 /// </summary>
 public static class McpClientExtensions
 {
+    /// <summary>
+    /// A request from the client to the server, to enable or adjust logging.
+    /// </summary>
+    /// <param name="client">The client.</param>
+    /// <param name="loggingLevel">The logging level severity to set.</param>
+    /// <param name="cancellationToken">A token to cancel the operation.</param>
+    /// <returns></returns>
+    public static Task SetLogLevelAsync(this IMcpClient client, LoggingLevel loggingLevel, CancellationToken cancellationToken = default)
+    {
+        Throw.IfNull(client);
+        return client.SendNotificationAsync("logging/setLevel", new SetLevelRequestParams { Level = loggingLevel }, cancellationToken);
+    }
+
     /// <summary>
     /// Sends a notification to the server with parameters.
     /// </summary>

src/ModelContextProtocol/Logging/McpLogger.cs

@@ -0,0 +1,42 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using ModelContextProtocol.Protocol.Types;
+using ModelContextProtocol.Server;
+using System.Text.Json;
+using System.Diagnostics.CodeAnalysis;
+
+namespace ModelContextProtocol.Logging;
+
+internal class McpLogger(string categoryName, IMcpServer mcpServer) : ILogger
+{
+    public IDisposable? BeginScope<TState>(TState state) where TState : notnull
+        => default;
+
+    public bool IsEnabled(LogLevel logLevel)
+        => logLevel.ToLoggingLevel() <= mcpServer.LoggingLevel;
+
+    [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "<Pending>")]
+    [UnconditionalSuppressMessage("AOT", "IL3050:Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.", Justification = "<Pending>")]
+    public async void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+    {
+        if (!IsEnabled(logLevel))
+            return;
+
+        var message = formatter(state, exception);
+        if (string.IsNullOrEmpty(message))
+            return;
+
+        // Use JsonSerializer to properly escape the string for JSON and turn it into a JsonElement
+        var json = JsonSerializer.Serialize(message);
+        var element = JsonSerializer.Deserialize<JsonElement>(json);
+
+        await mcpServer.SendLogNotificationAsync(new LoggingMessageNotificationParams
+        {
+            Data = element,
+            Level = logLevel.ToLoggingLevel(),
+            Logger = categoryName
+        });
+    }
+}

src/ModelContextProtocol/Logging/McpLoggerProvider.cs

@@ -0,0 +1,30 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using ModelContextProtocol.Server;
+using System;
+using System.Collections.Concurrent;
+
+namespace ModelContextProtocol.Logging
+{
+    /// <summary>
+    /// Provides logging over MCP's notifications to send log messages to the client
+    /// </summary>
+    /// <param name="mcpServer">MCP Server.</param>
+    public class McpLoggerProvider(IMcpServer mcpServer) : ILoggerProvider
+    {
+        /// <summary>
+        /// Creates a new instance of an MCP logger
+        /// </summary>
+        /// <param name="categoryName">Logger Category Name</param>
+        /// <returns>New Logger instance</returns>
+        public ILogger CreateLogger(string categoryName)
+            => new McpLogger(categoryName, mcpServer);
+
+        /// <summary>
+        /// Dispose
+        /// </summary>
+        public void Dispose()
+        {
+        }
+    }
+}

src/ModelContextProtocol/Logging/McpLoggingLevelExtensions.cs

@@ -0,0 +1,29 @@
+using Microsoft.Extensions.Logging;
+using ModelContextProtocol.Protocol.Types;
+
+namespace ModelContextProtocol.Logging;
+
+    internal static class McpLoggingLevelExtensions
+{
+    public static LogLevel ToLogLevel(this LoggingLevel level)
+        => level switch
+        {
+            LoggingLevel.Emergency or LoggingLevel.Alert or LoggingLevel.Critical => LogLevel.Critical,
+            LoggingLevel.Error => LogLevel.Error,
+            LoggingLevel.Warning => LogLevel.Warning,
+            LoggingLevel.Notice or LoggingLevel.Info => LogLevel.Information,
+            LoggingLevel.Debug => LogLevel.Debug,
+            _ => LogLevel.None,
+        };
+
+    public static LoggingLevel ToLoggingLevel(this LogLevel level)
+        => level switch
+        {
+            LogLevel.Critical => LoggingLevel.Critical,
+            LogLevel.Error => LoggingLevel.Error,
+            LogLevel.Warning => LoggingLevel.Warning,
+            LogLevel.Information => LoggingLevel.Info,
+            LogLevel.Debug or LogLevel.Trace => LoggingLevel.Debug,
+            _ => LoggingLevel.Info,
+        };
+}

src/ModelContextProtocol/Server/IMcpServer.cs

@@ -28,6 +28,11 @@ public interface IMcpServer : IAsyncDisposable
     /// </summary>
     IServiceProvider? ServiceProvider { get; }
 
+    /// <summary>
+    /// Current Logging level
+    /// </summary>
+    LoggingLevel LoggingLevel { get; }
+
     /// <summary>
     /// Adds a handler for client notifications of a specific method.
     /// </summary>

src/ModelContextProtocol/Server/McpServer.cs

@@ -35,6 +35,10 @@ public McpServer(ITransport transport, McpServerOptions options, ILoggerFactory?
 
         _serverTransport = transport as IServerTransport;
         _options = options;
+
+        // Add the MCP Logger provider to send MCP notification messages to the client when logs occur
+        loggerFactory?.AddProvider(new McpLoggerProvider(this));
+
         _logger = (ILogger?)loggerFactory?.CreateLogger<McpServer>() ?? NullLogger.Instance;
         ServerInstructions = options.ServerInstructions;
         ServiceProvider = serviceProvider;
@@ -44,6 +48,7 @@ public McpServer(ITransport transport, McpServerOptions options, ILoggerFactory?
             IsInitialized = true;
             return Task.CompletedTask;
         });
+        AddLoggingLevelNotificationHandler(options);
 
         SetInitializeHandler(options);
         SetCompletionHandler(options);
@@ -65,6 +70,8 @@ public McpServer(ITransport transport, McpServerOptions options, ILoggerFactory?
     /// <inheritdoc />
     public IServiceProvider? ServiceProvider { get; }
 
+    public LoggingLevel LoggingLevel { get; private set; }
+
     /// <inheritdoc />
     public override string EndpointName =>
         $"Server ({_options.ServerInfo.Name} {_options.ServerInfo.Version}), Client ({ClientInfo?.Name} {ClientInfo?.Version})";
@@ -140,6 +147,18 @@ options.GetCompletionHandler is { } handler ?
                 (request, ct) => Task.FromResult(new CompleteResult() { Completion = new() { Values = [], Total = 0, HasMore = false } }));
     }
 
+    private void AddLoggingLevelNotificationHandler(McpServerOptions options)
+    {
+        AddNotificationHandler("notifications/message", notification =>
+        {
+            if (notification.Params is LoggingMessageNotificationParams loggingMessageNotificationParams)
+            {
+                LoggingLevel = loggingMessageNotificationParams.Level;
+            }
+            return Task.CompletedTask;
+        });
+    }
+
     private void SetResourcesHandler(McpServerOptions options)
     {
         if (options.Capabilities?.Resources is not { } resourcesCapability)

src/ModelContextProtocol/Server/McpServerExtensions.cs

@@ -10,6 +10,22 @@ namespace ModelContextProtocol.Server;
 /// <inheritdoc />
 public static class McpServerExtensions
 {
+    /// <summary>
+    /// Sends a logging message notification to the client.
+    /// </summary>
+    /// <param name="server">The server instance that will handle the log notification request.</param>
+    /// <param name="loggingMessageNotification">Contains the details of the log message to be sent.</param>
+    /// <param name="cancellationToken">Allows the operation to be canceled if needed.</param>
+    /// <returns>Returns a task representing the asynchronous operation.</returns>
+    public static Task SendLogNotificationAsync(this IMcpServer server, LoggingMessageNotificationParams loggingMessageNotification, CancellationToken cancellationToken = default)
+    {
+        Throw.IfNull(server);
+        Throw.IfNull(loggingMessageNotification);
+        return server.SendRequestAsync<EmptyResult>(
+            new JsonRpcRequest { Method = "notifications/message", Params = loggingMessageNotification },
+            cancellationToken);
+    }
+
     /// <summary>
     /// Requests to sample an LLM via the client.
     /// </summary>