Fix logs still appearing even when LogLevel is set to none bug

src/Cli.Tests/EndToEndTests.cs

@@ -821,24 +821,12 @@ public Task TestUpdatingStoredProcedureWithRestMethods()
     [DataRow("--LogLevel 0", DisplayName = "LogLevel 0 from command line.")]
     [DataRow("--LogLevel 1", DisplayName = "LogLevel 1 from command line.")]
     [DataRow("--LogLevel 2", DisplayName = "LogLevel 2 from command line.")]
-    [DataRow("--LogLevel 3", DisplayName = "LogLevel 3 from command line.")]
-    [DataRow("--LogLevel 4", DisplayName = "LogLevel 4 from command line.")]
-    [DataRow("--LogLevel 5", DisplayName = "LogLevel 5 from command line.")]
-    [DataRow("--LogLevel 6", DisplayName = "LogLevel 6 from command line.")]
     [DataRow("--LogLevel Trace", DisplayName = "LogLevel Trace from command line.")]
     [DataRow("--LogLevel Debug", DisplayName = "LogLevel Debug from command line.")]
     [DataRow("--LogLevel Information", DisplayName = "LogLevel Information from command line.")]
-    [DataRow("--LogLevel Warning", DisplayName = "LogLevel Warning from command line.")]
-    [DataRow("--LogLevel Error", DisplayName = "LogLevel Error from command line.")]
-    [DataRow("--LogLevel Critical", DisplayName = "LogLevel Critical from command line.")]
-    [DataRow("--LogLevel None", DisplayName = "LogLevel None from command line.")]
     [DataRow("--LogLevel tRace", DisplayName = "Case sensitivity: LogLevel Trace from command line.")]
     [DataRow("--LogLevel DebUG", DisplayName = "Case sensitivity: LogLevel Debug from command line.")]
     [DataRow("--LogLevel information", DisplayName = "Case sensitivity: LogLevel Information from command line.")]
-    [DataRow("--LogLevel waRNing", DisplayName = "Case sensitivity: LogLevel Warning from command line.")]
-    [DataRow("--LogLevel eRROR", DisplayName = "Case sensitivity: LogLevel Error from command line.")]
-    [DataRow("--LogLevel CrItIcal", DisplayName = "Case sensitivity: LogLevel Critical from command line.")]
-    [DataRow("--LogLevel NONE", DisplayName = "Case sensitivity: LogLevel None from command line.")]
     public void TestEngineStartUpWithVerboseAndLogLevelOptions(string logLevelOption)
     {
         _fileSystem!.File.WriteAllText(TEST_RUNTIME_CONFIG_FILE, INITIAL_CONFIG);
@@ -857,6 +845,39 @@ public void TestEngineStartUpWithVerboseAndLogLevelOptions(string logLevelOption
         StringAssert.Contains(output, $"User provided config file: {TEST_RUNTIME_CONFIG_FILE}", StringComparison.Ordinal);
     }
 
+    /// <summary>
+    /// Test to validate that the engine starts successfully when --LogLevel is set to Warning
+    /// or above. At these levels, CLI phase messages (logged at Information) are suppressed,
+    /// so no stdout output is expected during the CLI phase.
+    /// </summary>
+    /// <param name="logLevelOption">Log level options</param>
+    [DataTestMethod]
+    [DataRow("--LogLevel 3", DisplayName = "LogLevel 3 from command line.")]
+    [DataRow("--LogLevel 4", DisplayName = "LogLevel 4 from command line.")]
+    [DataRow("--LogLevel 5", DisplayName = "LogLevel 5 from command line.")]
+    [DataRow("--LogLevel 6", DisplayName = "LogLevel 6 from command line.")]
+    [DataRow("--LogLevel Warning", DisplayName = "LogLevel Warning from command line.")]
+    [DataRow("--LogLevel Error", DisplayName = "LogLevel Error from command line.")]
+    [DataRow("--LogLevel Critical", DisplayName = "LogLevel Critical from command line.")]
+    [DataRow("--LogLevel None", DisplayName = "LogLevel None from command line.")]
+    [DataRow("--LogLevel waRNing", DisplayName = "Case sensitivity: LogLevel Warning from command line.")]
+    [DataRow("--LogLevel eRROR", DisplayName = "Case sensitivity: LogLevel Error from command line.")]
+    [DataRow("--LogLevel CrItIcal", DisplayName = "Case sensitivity: LogLevel Critical from command line.")]
+    [DataRow("--LogLevel NONE", DisplayName = "Case sensitivity: LogLevel None from command line.")]
+    public void TestEngineStartUpWithHighLogLevelOptions(string logLevelOption)
+    {
+        _fileSystem!.File.WriteAllText(TEST_RUNTIME_CONFIG_FILE, INITIAL_CONFIG);
+
+        using Process process = ExecuteDabCommand(
+            command: $"start --config {TEST_RUNTIME_CONFIG_FILE}",
+            logLevelOption
+        );
+
+        string? output = process.StandardOutput.ReadLine();
+        Assert.IsNull(output);
+        process.Kill();
+    }
+
     /// <summary>
     /// Validates that valid usage of verbs and associated options produce exit code 0 (CliReturnCode.SUCCESS).
     /// Verifies that explicitly implemented verbs (add, update, init, start) and appropriately

src/Cli.Tests/UtilsTests.cs

@@ -253,9 +253,11 @@ public void TestMergeConfig()
 
         FileSystemRuntimeConfigLoader loader = new(fileSystem);
 
+        LogBuffer logBuffer = new();
+
         Environment.SetEnvironmentVariable(RUNTIME_ENVIRONMENT_VAR_NAME, "Test");
 
-        Assert.IsTrue(ConfigMerger.TryMergeConfigsIfAvailable(fileSystem, loader, new StringLogger(), out string? mergedConfig), "Failed to merge config files");
+        Assert.IsTrue(ConfigMerger.TryMergeConfigsIfAvailable(fileSystem, loader, new StringLogger(), logBuffer, out string? mergedConfig), "Failed to merge config files");
         Assert.AreEqual(mergedConfig, "dab-config.Test.merged.json");
         Assert.IsTrue(fileSystem.File.Exists(mergedConfig));
         Assert.IsTrue(JToken.DeepEquals(JObject.Parse(MERGED_CONFIG), JObject.Parse(fileSystem.File.ReadAllText(mergedConfig))));
@@ -306,10 +308,11 @@ public void TestMergeConfigAvailability(
         }
 
         FileSystemRuntimeConfigLoader loader = new(fileSystem);
+        LogBuffer logBuffer = new();
 
         Assert.AreEqual(
             expectedIsMergedConfigAvailable,
-            ConfigMerger.TryMergeConfigsIfAvailable(fileSystem, loader, new StringLogger(), out string? mergedConfigFile),
+            ConfigMerger.TryMergeConfigsIfAvailable(fileSystem, loader, new StringLogger(), logBuffer, out string? mergedConfigFile),
             "Availability of merge config should match");
         Assert.AreEqual(expectedMergedConfigFileName, mergedConfigFile, "Merge config file name should match expected");
 

src/Cli/Commands/StartOptions.cs

@@ -19,6 +19,8 @@ public class StartOptions : Options
     {
         private const string LOGLEVEL_HELPTEXT = "Specifies logging level as provided value. For possible values, see: https://go.microsoft.com/fwlink/?linkid=2263106";
 
+        public LogBuffer CliBuffer { get; }
+
         public StartOptions(bool verbose, LogLevel? logLevel, bool isHttpsRedirectionDisabled, bool mcpStdio, string? mcpRole, string config)
             : base(config)
         {
@@ -27,6 +29,7 @@ public StartOptions(bool verbose, LogLevel? logLevel, bool isHttpsRedirectionDis
             IsHttpsRedirectionDisabled = isHttpsRedirectionDisabled;
             McpStdio = mcpStdio;
             McpRole = mcpRole;
+            CliBuffer = new LogBuffer();
         }
 
         // SetName defines mutually exclusive sets, ie: can not have
@@ -48,11 +51,15 @@ public StartOptions(bool verbose, LogLevel? logLevel, bool isHttpsRedirectionDis
 
         public int Handler(ILogger logger, FileSystemRuntimeConfigLoader loader, IFileSystem fileSystem)
         {
-            logger.LogInformation("{productName} {version}", PRODUCT_NAME, ProductInfo.GetProductVersion());
+            CliBuffer.BufferLog(Microsoft.Extensions.Logging.LogLevel.Information, $"{PRODUCT_NAME} {ProductInfo.GetProductVersion()}");
             bool isSuccess = ConfigGenerator.TryStartEngineWithOptions(this, loader, fileSystem);
 
             if (!isSuccess)
             {
+                // Update loggers and flush buffers to ensure that all the logs are printed if the TryStartEngineWithOptions fails.
+                logger = Utils.LoggerFactoryForCli.CreateLogger<Program>();
+                CliBuffer.FlushToLogger(logger);
+
                 logger.LogError("Failed to start the engine{mode}.",
                     McpStdio ? " in MCP stdio mode" : string.Empty);
             }

src/Cli/ConfigGenerator.cs

@@ -2555,7 +2555,7 @@ public static bool VerifyCanUpdateRelationship(RuntimeConfig runtimeConfig, stri
         /// </summary>
         public static bool TryStartEngineWithOptions(StartOptions options, FileSystemRuntimeConfigLoader loader, IFileSystem fileSystem)
         {
-            if (!TryGetConfigForRuntimeEngine(options.Config, loader, fileSystem, out string runtimeConfigFile))
+            if (!TryGetConfigForRuntimeEngine(options.Config, loader, fileSystem, out string runtimeConfigFile, options.CliBuffer))
             {
                 return false;
             }
@@ -2564,17 +2564,17 @@ public static bool TryStartEngineWithOptions(StartOptions options, FileSystemRun
             // Replaces all the environment variables while deserializing when starting DAB.
             if (!loader.TryLoadKnownConfig(out RuntimeConfig? deserializedRuntimeConfig, replaceEnvVar: true))
             {
-                _logger.LogError("Failed to parse the config file: {runtimeConfigFile}.", runtimeConfigFile);
+                options.CliBuffer.BufferLog(LogLevel.Error, $"Failed to parse the config file: {runtimeConfigFile}.");
                 return false;
             }
             else
             {
-                _logger.LogInformation("Loaded config file: {runtimeConfigFile}", runtimeConfigFile);
+                options.CliBuffer.BufferLog(LogLevel.Information, $"Loaded config file: {runtimeConfigFile}");
             }
 
             if (string.IsNullOrWhiteSpace(deserializedRuntimeConfig.DataSource.ConnectionString))
             {
-                _logger.LogError("Invalid connection-string provided in the config.");
+                options.CliBuffer.BufferLog(LogLevel.Error, "Invalid connection-string provided in the config.");
                 return false;
             }
 
@@ -2589,23 +2589,36 @@ public static bool TryStartEngineWithOptions(StartOptions options, FileSystemRun
             {
                 if (options.LogLevel is < LogLevel.Trace or > LogLevel.None)
                 {
-                    _logger.LogError(
-                        "LogLevel's valid range is 0 to 6, your value: {logLevel}, see: https://learn.microsoft.com/dotnet/api/microsoft.extensions.logging.loglevel",
-                        options.LogLevel);
+                    options.CliBuffer.BufferLog(LogLevel.Error,
+                        $"LogLevel's valid range is 0 to 6, your value: {options.LogLevel}, see: https://learn.microsoft.com/dotnet/api/microsoft.extensions.logging.loglevel");
                     return false;
                 }
 
                 minimumLogLevel = (LogLevel)options.LogLevel;
-                _logger.LogInformation("Setting minimum LogLevel: {minimumLogLevel}.", minimumLogLevel);
+                options.CliBuffer.BufferLog(LogLevel.Information, $"Setting minimum LogLevel: {minimumLogLevel}.");
             }
             else
             {
                 minimumLogLevel = deserializedRuntimeConfig.GetConfiguredLogLevel();
                 HostMode hostModeType = deserializedRuntimeConfig.IsDevelopmentMode() ? HostMode.Development : HostMode.Production;
 
-                _logger.LogInformation($"Setting default minimum LogLevel: {minimumLogLevel} for {hostModeType} mode.", minimumLogLevel, hostModeType);
+                options.CliBuffer.BufferLog(LogLevel.Information, $"Setting default minimum LogLevel: {minimumLogLevel} for {hostModeType} mode.");
             }
 
+            Utils.LoggerFactoryForCli = Utils.GetLoggerFactoryForCli(minimumLogLevel);
+
+            // Update logger for StartOptions
+            ILogger<Program> programLogger = Utils.LoggerFactoryForCli.CreateLogger<Program>();
+            options.CliBuffer.FlushToLogger(programLogger);
+
+            // Update logger for Utils
+            ILogger<Utils> utilsLogger = Utils.LoggerFactoryForCli.CreateLogger<Utils>();
+            Utils.SetCliUtilsLogger(utilsLogger);
+
+            // Update logger for ConfigGenerator
+            ILogger<ConfigGenerator> configGeneratorLogger = Utils.LoggerFactoryForCli.CreateLogger<ConfigGenerator>();
+            SetLoggerForCliConfigGenerator(configGeneratorLogger);
+
             args.Add("--LogLevel");
             args.Add(minimumLogLevel.ToString());
 
@@ -2696,16 +2709,32 @@ public static bool TryGetConfigForRuntimeEngine(
             string? configToBeUsed,
             FileSystemRuntimeConfigLoader loader,
             IFileSystem fileSystem,
-            out string runtimeConfigFile)
+            out string runtimeConfigFile,
+            LogBuffer? logBuffer = null)
         {
-            if (string.IsNullOrEmpty(configToBeUsed) && ConfigMerger.TryMergeConfigsIfAvailable(fileSystem, loader, _logger, out configToBeUsed))
+            if (string.IsNullOrEmpty(configToBeUsed) && ConfigMerger.TryMergeConfigsIfAvailable(fileSystem, loader, _logger, logBuffer, out configToBeUsed))
             {
-                _logger.LogInformation("Using merged config file based on environment: {configToBeUsed}.", configToBeUsed);
+                if (logBuffer is null)
+                {
+                    _logger.LogInformation("Using merged config file based on environment,: {configToBeUsed}.", configToBeUsed);
+                }
+                else
+                {
+                    logBuffer.BufferLog(LogLevel.Information, $"Merged config file based on environment is available: {configToBeUsed}.");
+                }
             }
 
-            if (!TryGetConfigFileBasedOnCliPrecedence(loader, configToBeUsed, out runtimeConfigFile))
+            if (!TryGetConfigFileBasedOnCliPrecedence(loader, configToBeUsed, out runtimeConfigFile, logBuffer))
             {
-                _logger.LogError("Config not provided and default config file doesn't exist.");
+                if (logBuffer is null)
+                {
+                    _logger.LogError("Config not provided and default config file doesn't exist.");
+                }
+                else
+                {
+                    logBuffer.BufferLog(LogLevel.Error, "Config not provided and default config file doesn't exist.");
+                }
+
                 return false;
             }
 

src/Cli/ConfigMerger.cs

@@ -15,7 +15,7 @@ public static class ConfigMerger
     /// and create a merged file called dab-config.{DAB_ENVIRONMENT}.merged.json
     /// </summary>
     /// <returns>Returns the name of the merged Config if successful.</returns>
-    public static bool TryMergeConfigsIfAvailable(IFileSystem fileSystem, FileSystemRuntimeConfigLoader loader, ILogger logger, out string? mergedConfigFile)
+    public static bool TryMergeConfigsIfAvailable(IFileSystem fileSystem, FileSystemRuntimeConfigLoader loader, ILogger logger, LogBuffer? cliBuffer, out string? mergedConfigFile)
     {
         string? environmentValue = Environment.GetEnvironmentVariable(FileSystemRuntimeConfigLoader.RUNTIME_ENVIRONMENT_VAR_NAME);
         mergedConfigFile = null;
@@ -32,16 +32,42 @@ public static bool TryMergeConfigsIfAvailable(IFileSystem fileSystem, FileSystem
                     string overrideConfigJson = fileSystem.File.ReadAllText(environmentBasedConfigFile);
 
                     string currentDir = fileSystem.Directory.GetCurrentDirectory();
-                    logger.LogInformation("Merging {baseFilePath} and {envFilePath}", Path.Combine(currentDir, baseConfigFile), Path.Combine(currentDir, environmentBasedConfigFile));
+
+                    if (cliBuffer is null)
+                    {
+                        logger.LogInformation("Merging {baseFilePath} and {envFilePath}", Path.Combine(currentDir, baseConfigFile), Path.Combine(currentDir, environmentBasedConfigFile));
+                    }
+                    else
+                    {
+                        cliBuffer.BufferLog(LogLevel.Information, $"Merging {Path.Combine(currentDir, baseConfigFile)} and {Path.Combine(currentDir, environmentBasedConfigFile)}");
+                    }
+
                     string mergedConfigJson = MergeJsonProvider.Merge(baseConfigJson, overrideConfigJson);
                     mergedConfigFile = FileSystemRuntimeConfigLoader.GetMergedFileNameForEnvironment(FileSystemRuntimeConfigLoader.CONFIGFILE_NAME, environmentValue);
                     fileSystem.File.WriteAllText(mergedConfigFile, mergedConfigJson);
-                    logger.LogInformation("Generated merged config file: {mergedFile}", Path.Combine(currentDir, mergedConfigFile));
+
+                    if (cliBuffer is null)
+                    {
+                        logger.LogInformation("Generated merged config file: {mergedFile}", Path.Combine(currentDir, mergedConfigFile));
+                    }
+                    else
+                    {
+                        cliBuffer.BufferLog(LogLevel.Information, $"Generated merged config file: {Path.Combine(currentDir, mergedConfigFile)}");
+                    }
+
                     return true;
                 }
                 catch (Exception ex)
                 {
-                    logger.LogError(ex, "Failed to merge the config files.");
+                    if (cliBuffer is null)
+                    {
+                        logger.LogError(ex, "Failed to merge the config files.");
+                    }
+                    else
+                    {
+                        cliBuffer.BufferLog(LogLevel.Error, "Failed to merge the config files.", ex);
+                    }
+
                     mergedConfigFile = null;
                     return false;
                 }

src/Cli/CustomLoggerProvider.cs

@@ -8,18 +8,30 @@
 /// </summary>
 public class CustomLoggerProvider : ILoggerProvider
 {
+    private readonly LogLevel _minimumLogLevel;
+
+    public CustomLoggerProvider(LogLevel minimumLogLevel = LogLevel.Information)
+    {
+        _minimumLogLevel = minimumLogLevel;
+    }
+
     public void Dispose() { }
 
     /// <inheritdoc/>
     public ILogger CreateLogger(string categoryName)
     {
-        return new CustomConsoleLogger();
+        return new CustomConsoleLogger(_minimumLogLevel);
     }
 
     public class CustomConsoleLogger : ILogger
     {
         // Minimum LogLevel. LogLevel below this would be disabled.
-        private readonly LogLevel _minimumLogLevel = LogLevel.Information;
+        private readonly LogLevel _minimumLogLevel;
+
+        public CustomConsoleLogger(LogLevel minimumLogLevel = LogLevel.Information)
+        {
+            _minimumLogLevel = minimumLogLevel;
+        }
 
         //  Color values based on LogLevel
         //  LogLevel    Foreground      Background
@@ -74,7 +86,7 @@ public class CustomConsoleLogger : ILogger
         /// </summary>
         public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
         {
-            if (!IsEnabled(logLevel) || logLevel < _minimumLogLevel)
+            if (!IsEnabled(logLevel))
             {
                 return;
             }
@@ -97,8 +109,9 @@ public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Except
         /// <inheritdoc/>
         public bool IsEnabled(LogLevel logLevel)
         {
-            return true;
+            return logLevel != LogLevel.None && logLevel >= _minimumLogLevel;
         }
+
         public IDisposable? BeginScope<TState>(TState state) where TState : notnull
         {
             throw new NotImplementedException();

src/Cli/Exporter.cs

@@ -37,7 +37,7 @@ internal class Exporter
         public static bool Export(ExportOptions options, ILogger logger, FileSystemRuntimeConfigLoader loader, IFileSystem fileSystem)
         {
             // Attempt to locate the runtime configuration file based on CLI options
-            if (!TryGetConfigFileBasedOnCliPrecedence(loader, options.Config, out string runtimeConfigFile))
+            if (!TryGetConfigFileBasedOnCliPrecedence(loader: loader, userProvidedConfigFile: options.Config, runtimeConfigFile: out string runtimeConfigFile))
             {
                 logger.LogError("Failed to find the config file provided, check your options and try again.");
                 return false;