Improving how to setup logging and implementing logging handler

Author: aaronpowell

samples/EverythingServer/LoggingUpdateMessageSender.cs

@@ -0,0 +1,54 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using ModelContextProtocol.Protocol.Messages;
+using ModelContextProtocol.Protocol.Types;
+using ModelContextProtocol.Server;
+
+namespace EverythingServer;
+
+public class LoggingUpdateMessageSender(IMcpServer server) : IHostedService
+{
+    readonly Dictionary<LoggingLevel, string> _loggingLevelMap = new()
+    {
+        { LoggingLevel.Debug, "Debug-level message" },
+        { LoggingLevel.Info, "Info-level message" },
+        { LoggingLevel.Notice, "Notice-level message" },
+        { LoggingLevel.Warning, "Warning-level message" },
+        { LoggingLevel.Error, "Error-level message" },
+        { LoggingLevel.Critical, "Critical-level message" },
+        { LoggingLevel.Alert, "Alert-level message" },
+        { LoggingLevel.Emergency, "Emergency-level message" }
+    };
+
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        var currentLevel = server.Services!.GetRequiredService<Func<LoggingLevel>>();
+
+        while (!cancellationToken.IsCancellationRequested)
+        {
+            var newLevel = (LoggingLevel)Enum.GetValues<LoggingLevel>().GetValue(new Random().Next(0, Enum.GetValues(typeof(LoggingLevel)).Length))!;
+
+            var message = new JsonRpcNotification
+            {
+                Method = "notifications/message",
+                Params = new
+                {
+                    Level = newLevel.ToString().ToLower(),
+                    Data = _loggingLevelMap[newLevel],
+                }
+            };
+
+            if (newLevel > currentLevel())
+            {
+                await server.SendMessageAsync(message, cancellationToken);
+            }
+
+            await Task.Delay(15000, cancellationToken);
+        }
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+}

samples/EverythingServer/Program.cs

@@ -6,10 +6,12 @@
 using Microsoft.Extensions.DependencyInjection;
 using EverythingServer.Prompts;
 using EverythingServer.Tools;
+using ModelContextProtocol.Protocol.Messages;
 
 var builder = Host.CreateEmptyApplicationBuilder(settings: null);
 
 HashSet<string> subscriptions = [];
+var _minimumLoggingLevel = LoggingLevel.Debug;
 
 builder.Services
     .AddMcpServer()
@@ -158,6 +160,28 @@ await ctx.Server.RequestSamplingAsync([
 
         throw new NotSupportedException($"Unknown reference type: {@ref.Type}");
     })
+    .WithSetLoggingLevelHandler(async (ctx, ct) =>
+    {
+        if (ctx.Params?.Level is null)
+        {
+            throw new McpServerException("Missing required argument 'level'");
+        }
+
+        _minimumLoggingLevel = ctx.Params.Level;
+
+        await ctx.Server.SendMessageAsync(new JsonRpcNotification
+        {
+            Method = "notifications/message",
+            Params = new
+            {
+                Level = "debug",
+                Logger = "test-server",
+                Data = $"Logging level set to {_minimumLoggingLevel}",
+            }
+        }, ct);
+
+        return new EmptyResult();
+    })
     ;
 
 builder.Services.AddHostedService(sp =>
@@ -166,4 +190,12 @@ await ctx.Server.RequestSamplingAsync([
     return new SubscriptionMessageSender(server, subscriptions);
 });
 
+builder.Services.AddHostedService(sp =>
+{
+    var server = sp.GetRequiredService<IMcpServer>();
+    return new LoggingUpdateMessageSender(server);
+});
+
+builder.Services.AddScoped<Func<LoggingLevel>>(_ => () => _minimumLoggingLevel);
+
 await builder.Build().RunAsync();

src/ModelContextProtocol/Configuration/McpServerBuilderExtensions.cs

@@ -314,7 +314,7 @@ public static IMcpServerBuilder WithSubscribeToResourcesHandler(this IMcpServerB
     }
 
     /// <summary>
-    /// Sets or sets the handler for subscribe to resources messages.
+    /// Sets the handler for subscribe to resources messages.
     /// </summary>
     /// <param name="builder">The builder instance.</param>
     /// <param name="handler">The handler.</param>
@@ -325,6 +325,18 @@ public static IMcpServerBuilder WithUnsubscribeFromResourcesHandler(this IMcpSer
         builder.Services.Configure<McpServerHandlers>(s => s.UnsubscribeFromResourcesHandler = handler);
         return builder;
     }
+
+    /// <summary>
+    /// Sets the handler for setting the logging level.
+    /// </summary>
+    /// <param name="builder">The builder instance.</param>
+    /// <param name="handler">The handler.</param>
+    public static IMcpServerBuilder WithSetLoggingLevelHandler(this IMcpServerBuilder builder, Func<RequestContext<SetLevelRequestParams>, CancellationToken, Task<EmptyResult>> handler)
+    {
+        Throw.IfNull(builder);
+        builder.Services.Configure<McpServerHandlers>(s => s.SetLoggingLevelHandler = handler);
+        return builder;
+    }
     #endregion
 
     #region Transports

src/ModelContextProtocol/Server/McpServerHandlers.cs

@@ -113,6 +113,7 @@ internal void OverwriteWithSetHandlers(McpServerOptions options)
         options.Capabilities.Prompts = promptsCapability;
         options.Capabilities.Resources = resourcesCapability;
         options.Capabilities.Tools = toolsCapability;
+        options.Capabilities.Logging = loggingCapability;
 
         options.GetCompletionHandler = GetCompletionHandler ?? options.GetCompletionHandler;
     }