Implemented MCP Set Log Level (#3419)

## Why make this change?

Closes #3274 - MCP Server returns "Method not found: logging/setLevel"
error when clients send the standard MCP logging/setLevel request.

Closes #3275 - Control output in MCP stdio mode (default to
`LogLevel.None`, redirect/suppress console output).

## What is this change?

### MCP `logging/setLevel` Handler
- Added handler for `logging/setLevel` JSON-RPC method in
`McpStdioServer.cs`
- Implemented `DynamicLogLevelProvider` with `ILogLevelController`
interface to allow MCP to update log levels dynamically
- Added `IsCliOverridden` and `IsConfigOverridden` properties to enforce
precedence rules

### Log Level Precedence System
**Precedence (highest to lowest):**
1. **CLI `--LogLevel` flag** - cannot be changed by MCP
2. **Config `runtime.telemetry.log-level`** - cannot be changed by MCP  
3. **MCP `logging/setLevel`** - only works if neither CLI nor config set
a level
4.  Default (LogLevel.None for MCP stdio mode)

If CLI or config set a level, MCP requests are accepted but silently
ignored (no error returned per MCP spec).

### Early Config Reading for MCP Mode
- Added `TryGetLogLevelFromConfig()` in `Program.cs` to read config file
early (before host build)
- This ensures config log level is detected before Console redirect
decision
- Console redirect for MCP stdio mode now respects config log level

### CLI Log Level Handling
- Added `Utils.CliLogLevel` property to track the parsed `--LogLevel`
value
- CLI's `CustomLoggerProvider` now respects the `--LogLevel` value for
its own logging

### Config Helpers
- Added `HasExplicitLogLevel()` helper to `RuntimeConfig` to correctly
detect when config actually pins a log level
- This properly handles null values in telemetry section (null values
don't count as explicit override)

## How was this tested?

- [x] Unit Tests (`DynamicLogLevelProviderTests` - 5 tests)
- [x] Manual Testing

### Manual Test 1: No override (MCP can change level)
1. Start MCP server without `--LogLevel` and without config `log-level`
2. MCP sends `logging/setLevel` with `level: info`
3. Result: Log level changes to info

### Manual Test 2: CLI override (MCP blocked)
1. Start MCP server with `--LogLevel Warning`
2. MCP sends `logging/setLevel` with `level: info`
3. Result: Log level stays at Warning, MCP request accepted silently

### Manual Test 3: Config override (MCP blocked)
1. Add `"telemetry": { "log-level": { "default": "Warning" } }` to
config
2. Start MCP server without `--LogLevel`
3. MCP sends `logging/setLevel` with `level: info`
5. Result: Log level stays at Warning, MCP request accepted silently

### Manual Test 4: Config with null values (MCP can change level)
1. Add `"telemetry": { "log-level": { "default": null } }` to config
2. Start MCP server without `--LogLevel`
3. MCP sends `logging/setLevel` with `level: info`
4. Result: Log level changes to info (null values don't count as
override)

## Sample Request(s)

MCP client sends:
```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "logging/setLevel",
  "params": {
    "level": "info"
  }
}
```

Server responds with empty result (success per MCP spec) and updates log
level if no CLI/config override is active.

---------

Co-authored-by: RubenCerna2079 <32799214+RubenCerna2079@users.noreply.github.com>

Author: anushakolan

src/Azure.DataApiBuilder.Mcp/Core/McpStdioServer.cs

@@ -6,6 +6,7 @@
 using Azure.DataApiBuilder.Config.ObjectModel;
 using Azure.DataApiBuilder.Core.AuthenticationHelpers.AuthenticationSimulator;
 using Azure.DataApiBuilder.Core.Configurations;
+using Azure.DataApiBuilder.Core.Telemetry;
 using Azure.DataApiBuilder.Mcp.Model;
 using Azure.DataApiBuilder.Mcp.Utils;
 using Microsoft.AspNetCore.Http;
@@ -46,8 +47,6 @@ public McpStdioServer(McpToolRegistry toolRegistry, IServiceProvider serviceProv
         /// <returns>A task representing the asynchronous operation.</returns>
         public async Task RunAsync(CancellationToken cancellationToken)
         {
-            Console.Error.WriteLine("[MCP DEBUG] MCP stdio server started.");
-
             // Use UTF-8 WITHOUT BOM
             UTF8Encoding utf8NoBom = new(encoderShouldEmitUTF8Identifier: false);
 
@@ -77,15 +76,13 @@ public async Task RunAsync(CancellationToken cancellationToken)
                 {
                     doc = JsonDocument.Parse(line);
                 }
-                catch (JsonException jsonEx)
+                catch (JsonException)
                 {
-                    Console.Error.WriteLine($"[MCP DEBUG] JSON parse error: {jsonEx.Message}");
                     WriteError(id: null, code: McpStdioJsonRpcErrorCodes.PARSE_ERROR, message: "Parse error");
                     continue;
                 }
-                catch (Exception ex)
+                catch (Exception)
                 {
-                    Console.Error.WriteLine($"[MCP DEBUG] Unexpected error parsing request: {ex.Message}");
                     WriteError(id: null, code: McpStdioJsonRpcErrorCodes.INTERNAL_ERROR, message: "Internal error");
                     continue;
                 }
@@ -131,6 +128,10 @@ public async Task RunAsync(CancellationToken cancellationToken)
                                 WriteResult(id, new { ok = true });
                                 break;
 
+                            case "logging/setLevel":
+                                HandleSetLogLevel(id, root);
+                                break;
+
                             case "shutdown":
                                 WriteResult(id, new { ok = true });
                                 return;
@@ -171,30 +172,50 @@ private void HandleInitialize(JsonElement? id)
                     RuntimeConfig runtimeConfig = runtimeConfigProvider.GetConfig();
                     instructions = runtimeConfig.Runtime?.Mcp?.Description;
                 }
-                catch (Exception ex)
+                catch (Exception)
                 {
-                    // Log to stderr for diagnostics and rethrow to avoid masking configuration errors
-                    Console.Error.WriteLine($"[MCP WARNING] Failed to retrieve MCP description from config: {ex.Message}");
+                    // Rethrow to avoid masking configuration errors
                     throw;
                 }
             }
 
-            // Create the initialize response
-            object result = new
+            // Create the initialize response - only include instructions if non-empty
+            object result;
+            if (!string.IsNullOrWhiteSpace(instructions))
             {
-                protocolVersion = _protocolVersion,
-                capabilities = new
+                result = new
                 {
-                    tools = new { listChanged = true },
-                    logging = new { }
-                },
-                serverInfo = new
+                    protocolVersion = _protocolVersion,
+                    capabilities = new
+                    {
+                        tools = new { listChanged = true },
+                        logging = new { }
+                    },
+                    serverInfo = new
+                    {
+                        name = McpProtocolDefaults.MCP_SERVER_NAME,
+                        version = McpProtocolDefaults.MCP_SERVER_VERSION
+                    },
+                    instructions = instructions
+                };
+            }
+            else
+            {
+                result = new
                 {
-                    name = McpProtocolDefaults.MCP_SERVER_NAME,
-                    version = McpProtocolDefaults.MCP_SERVER_VERSION
-                },
-                instructions = !string.IsNullOrWhiteSpace(instructions) ? instructions : null
-            };
+                    protocolVersion = _protocolVersion,
+                    capabilities = new
+                    {
+                        tools = new { listChanged = true },
+                        logging = new { }
+                    },
+                    serverInfo = new
+                    {
+                        name = McpProtocolDefaults.MCP_SERVER_NAME,
+                        version = McpProtocolDefaults.MCP_SERVER_VERSION
+                    }
+                };
+            }
 
             WriteResult(id, result);
         }
@@ -228,6 +249,85 @@ private void HandleListTools(JsonElement? id)
             WriteResult(id, new { tools = toolsWire });
         }
 
+        /// <summary>
+        /// Handles the "logging/setLevel" JSON-RPC method by updating the runtime log level.
+        /// </summary>
+        /// <param name="id">The request identifier extracted from the incoming JSON-RPC request.</param>
+        /// <param name="root">The root JSON element of the incoming JSON-RPC request.</param>
+        /// <remarks>
+        /// Log level precedence (highest to lowest):
+        /// 1. CLI --LogLevel flag - cannot be overridden
+        /// 2. Config runtime.telemetry.log-level - cannot be overridden by MCP
+        /// 3. MCP logging/setLevel - only works if neither CLI nor Config explicitly set a level
+        /// 4. Default: None for MCP stdio mode (silent by default to keep stdout clean for JSON-RPC)
+        /// 
+        /// If CLI or Config set the log level, this method accepts the request but silently ignores it.
+        /// The client won't get an error, but CLI/Config wins.
+        /// 
+        /// When MCP sets a level other than "none", this also restores Console.Error to the real stderr
+        /// stream so that logs become visible (Console may have been redirected to null at startup).
+        /// It also enables MCP log notifications so logs are sent to the client via notifications/message.
+        /// </remarks>
+        private void HandleSetLogLevel(JsonElement? id, JsonElement root)
+        {
+            // Extract the level parameter from the request
+            string? level = null;
+            if (root.TryGetProperty("params", out JsonElement paramsEl) &&
+                paramsEl.TryGetProperty("level", out JsonElement levelEl) &&
+                levelEl.ValueKind == JsonValueKind.String)
+            {
+                level = levelEl.GetString();
+            }
+
+            if (string.IsNullOrWhiteSpace(level))
+            {
+                WriteError(id, McpStdioJsonRpcErrorCodes.INVALID_PARAMS, "Missing or invalid 'level' parameter");
+                return;
+            }
+
+            // Get the ILogLevelController from service provider
+            ILogLevelController? logLevelController = _serviceProvider.GetService<ILogLevelController>();
+            if (logLevelController is null)
+            {
+                // Log level controller not available - still accept request per MCP spec
+                WriteResult(id, new { });
+                return;
+            }
+
+            // Attempt to update the log level
+            // If CLI or Config overrode, this returns false but we still return success to the client
+            bool updated = logLevelController.UpdateFromMcp(level);
+
+            // If MCP successfully changed the log level to something other than "none",
+            // ensure Console.Error is pointing to the real stderr (not TextWriter.Null).
+            // This handles the case where MCP stdio mode started with LogLevel.None (quiet startup)
+            // and the client later enables logging via logging/setLevel.
+            bool isLoggingEnabled = !string.Equals(level, "none", StringComparison.OrdinalIgnoreCase);
+            if (updated && isLoggingEnabled)
+            {
+                RestoreStderrIfNeeded();
+            }
+
+            // Always return success (empty result object) per MCP spec
+            WriteResult(id, new { });
+        }
+
+        /// <summary>
+        /// Restores Console.Error to the real stderr stream if it was redirected to TextWriter.Null.
+        /// This enables log output after MCP client sends logging/setLevel with a level other than "none".
+        /// </summary>
+        private static void RestoreStderrIfNeeded()
+        {
+            // Always restore stderr to the real stream when MCP enables logging.
+            // This is safe to call multiple times - we just re-wrap the standard error stream.
+            Stream stderr = Console.OpenStandardError();
+            StreamWriter stderrWriter = new(stderr, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false))
+            {
+                AutoFlush = true
+            };
+            Console.SetError(stderrWriter);
+        }
+
         /// <summary>
         /// Handles the "tools/call" JSON-RPC method by executing the specified tool with the provided arguments.
         /// </summary>
@@ -259,14 +359,12 @@ private async Task HandleCallToolAsync(JsonElement? id, JsonElement root, Cancel
 
             if (string.IsNullOrWhiteSpace(toolName))
             {
-                Console.Error.WriteLine("[MCP DEBUG] callTool → missing tool name.");
                 WriteError(id, McpStdioJsonRpcErrorCodes.INVALID_PARAMS, "Missing tool name");
                 return;
             }
 
             if (!_toolRegistry.TryGetTool(toolName!, out IMcpTool? tool) || tool is null)
             {
-                Console.Error.WriteLine($"[MCP DEBUG] callTool → tool not found: {toolName}");
                 WriteError(id, McpStdioJsonRpcErrorCodes.INVALID_PARAMS, $"Tool not found: {toolName}");
                 return;
             }
@@ -276,13 +374,7 @@ private async Task HandleCallToolAsync(JsonElement? id, JsonElement root, Cancel
             {
                 if (@params.TryGetProperty("arguments", out JsonElement argsEl) && argsEl.ValueKind == JsonValueKind.Object)
                 {
-                    string rawArgs = argsEl.GetRawText();
-                    Console.Error.WriteLine($"[MCP DEBUG] callTool → tool: {toolName}, args: {rawArgs}");
-                    argsDoc = JsonDocument.Parse(rawArgs);
-                }
-                else
-                {
-                    Console.Error.WriteLine($"[MCP DEBUG] callTool → tool: {toolName}, args: <none>");
+                    argsDoc = JsonDocument.Parse(argsEl.GetRawText());
                 }
 
                 // Execute the tool with telemetry.

src/Cli/ConfigGenerator.cs

@@ -2582,8 +2582,12 @@ public static bool TryStartEngineWithOptions(StartOptions options, FileSystemRun
             List<string> args = new()
             { "--ConfigFileName", runtimeConfigFile };
 
-            /// Add arguments for LogLevel. Checks if LogLevel is overridden with option `--LogLevel`.
-            /// If not provided, Default minimum LogLevel is Debug for Development mode and Error for Production mode.
+            /// Add arguments for LogLevel. Only pass --LogLevel when user explicitly specified it,
+            /// so that MCP logging/setLevel can still adjust the level when no CLI override is present.
+            /// 
+            /// When --LogLevel is NOT specified:
+            /// - MCP stdio mode: Service defaults to None for clean stdout output
+            /// - Non-MCP mode: Service defaults to Debug (Development) or Error (Production) based on config
             LogLevel minimumLogLevel;
             if (options.LogLevel is not null)
             {
@@ -2596,6 +2600,8 @@ public static bool TryStartEngineWithOptions(StartOptions options, FileSystemRun
                 }
 
                 minimumLogLevel = (LogLevel)options.LogLevel;
+                // Only add --LogLevel when user explicitly specified it via CLI.
+                // This allows MCP logging/setLevel to work when no CLI override is present.
                 args.Add("--LogLevel");
                 args.Add(minimumLogLevel.ToString());
                 _logger.LogInformation("Setting minimum LogLevel: {minimumLogLevel}.", minimumLogLevel);

src/Cli/CustomLoggerProvider.cs

@@ -18,8 +18,13 @@ public ILogger CreateLogger(string categoryName)
 
     public class CustomConsoleLogger : ILogger
     {
-        // Minimum LogLevel. LogLevel below this would be disabled.
-        private readonly LogLevel _minimumLogLevel = LogLevel.Information;
+        // Minimum LogLevel for CLI output.
+        // For MCP mode: use CLI's --LogLevel if specified, otherwise suppress all.
+        // For non-MCP mode: always use Information.
+        // Note: --LogLevel is meant for the ENGINE's log level, not CLI's output.
+        private static LogLevel MinimumLogLevel => Cli.Utils.IsMcpStdioMode
+            ? (Cli.Utils.IsLogLevelOverriddenByCli ? Cli.Utils.CliLogLevel : LogLevel.None)
+            : LogLevel.Information;
 
         //  Color values based on LogLevel
         //  LogLevel    Foreground      Background
@@ -58,10 +63,39 @@ public class CustomConsoleLogger : ILogger
 
         /// <summary>
         /// Creates Log message by setting console message color based on LogLevel.
+        /// In MCP stdio mode:
+        /// - If user explicitly set --LogLevel: write to stderr (colored output)
+        /// - Otherwise: suppress entirely to keep stdout clean for JSON-RPC protocol.
         /// </summary>
         public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
         {
-            if (!IsEnabled(logLevel) || logLevel < _minimumLogLevel)
+            // In MCP stdio mode, only output logs if user explicitly requested a log level.
+            // In that case, write to stderr to keep stdout clean for JSON-RPC.
+            if (Cli.Utils.IsMcpStdioMode)
+            {
+                if (!Cli.Utils.IsLogLevelOverriddenByCli)
+                {
+                    return; // Suppress entirely when no explicit log level
+                }
+
+                // User wants logs in MCP mode - write to stderr
+                if (!IsEnabled(logLevel) || logLevel < MinimumLogLevel)
+                {
+                    return;
+                }
+
+                if (!_logLevelToAbbreviation.TryGetValue(logLevel, out string? mcpAbbreviation))
+                {
+                    return;
+                }
+
+                // In MCP stdio mode, stdout is reserved for JSON-RPC protocol messages.
+                // Logs must go to stderr to avoid corrupting the MCP communication channel.
+                Console.Error.WriteLine($"{mcpAbbreviation}: {formatter(state, exception)}");
+                return;
+            }
+
+            if (!IsEnabled(logLevel) || logLevel < MinimumLogLevel)
             {
                 return;
             }

src/Cli/Program.cs

@@ -26,6 +26,10 @@ public static int Main(string[] args)
             // Load environment variables from .env file if present.
             DotNetEnv.Env.Load();
 
+            // Parse MCP and LogLevel flags in a single pass for efficiency.
+            // These flags need to be known before logger creation.
+            ParseEarlyFlags(args);
+
             // Logger setup and configuration
             ILoggerFactory loggerFactory = Utils.LoggerFactoryForCli;
             ILogger<Program> cliLogger = loggerFactory.CreateLogger<Program>();
@@ -41,6 +45,32 @@ public static int Main(string[] args)
             return Execute(args, cliLogger, fileSystem, loader);
         }
 
+        /// <summary>
+        /// Parses flags that need to be known before logger creation.
+        /// Scans args in a single pass for efficiency.
+        /// </summary>
+        /// <param name="args">Command line arguments</param>
+        private static void ParseEarlyFlags(string[] args)
+        {
+            for (int i = 0; i < args.Length; i++)
+            {
+                string arg = args[i];
+
+                if (string.Equals(arg, "--mcp-stdio", StringComparison.OrdinalIgnoreCase))
+                {
+                    Utils.IsMcpStdioMode = true;
+                }
+                else if (string.Equals(arg, "--LogLevel", StringComparison.OrdinalIgnoreCase) && i + 1 < args.Length)
+                {
+                    Utils.IsLogLevelOverriddenByCli = true;
+                    if (Enum.TryParse<LogLevel>(args[i + 1], ignoreCase: true, out LogLevel cliLogLevel))
+                    {
+                        Utils.CliLogLevel = cliLogLevel;
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Execute the CLI command
         /// </summary>

src/Cli/Utils.cs

@@ -23,6 +23,23 @@ public class Utils
         public const string WILDCARD = "*";
         public static readonly string SEPARATOR = ":";
 
+        /// <summary>
+        /// When true, CLI logging to stdout is suppressed to keep the MCP stdio channel clean.
+        /// </summary>
+        public static bool IsMcpStdioMode { get; set; }
+
+        /// <summary>
+        /// When true, user explicitly set --LogLevel via CLI (even in MCP mode).
+        /// This allows logs to be written to stderr instead of being completely suppressed.
+        /// </summary>
+        public static bool IsLogLevelOverriddenByCli { get; set; }
+
+        /// <summary>
+        /// The log level specified via CLI --LogLevel flag.
+        /// Only valid when IsLogLevelOverriddenByCli is true.
+        /// </summary>
+        public static LogLevel CliLogLevel { get; set; } = LogLevel.Information;
+
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
         private static ILogger<Utils> _logger;
 #pragma warning restore CS8618

src/Config/Converters/EntityCacheOptionsConverterFactory.cs

@@ -125,7 +125,7 @@ public EntityCacheOptionsConverter(DeserializationVariableReplacementSettings? r
         /// when its corresponding UserProvided* flag is true. This avoids polluting the written
         /// JSON file with properties the user omitted (defaults or inherited values).
         /// If the user provided a cache object (Entity.Cache is non-null), we always write the
-        /// object — even if it ends up empty ("cache": {}) — because the user explicitly included it.
+        /// object — even if it ends up empty ("cache": {}) — because the user explicitly included it.
         /// Entity.Cache being null means the user never wrote a cache property, and the serializer's
         /// DefaultIgnoreCondition.WhenWritingNull suppresses the "cache" key entirely.
         /// </summary>