Fix dab validate error messaging when logger is not available

src/Cli.Tests/EndToEndTests.cs

@@ -1093,11 +1093,6 @@ public async Task TestExitOfRuntimeEngineWithInvalidConfig(
         {
             output = await process.StandardError.ReadLineAsync();
             Assert.IsNotNull(output);
-            StringAssert.Contains(output, $"Deserialization of the configuration file failed.", StringComparison.Ordinal);
-
-            output = await process.StandardOutput.ReadLineAsync();
-            Assert.IsNotNull(output);
-            StringAssert.Contains(output, $"Error: Failed to parse the config file: {TEST_RUNTIME_CONFIG_FILE}.", StringComparison.Ordinal);
 
             output = await process.StandardOutput.ReadLineAsync();
             Assert.IsNotNull(output);

src/Cli.Tests/EnvironmentTests.cs

@@ -163,8 +163,8 @@ public async Task FailureToStartEngineWhenEnvVarNamedWrong()
         );
 
         string? output = await process.StandardError.ReadLineAsync();
-        Assert.AreEqual("Deserialization of the configuration file failed during a post-processing step.", output);
-        output = await process.StandardError.ReadToEndAsync();
+        Assert.IsNotNull(output);
+        // Clean error message with no wrapper prefix or stack trace.
         StringAssert.Contains(output, "A valid Connection String should be provided.", StringComparison.Ordinal);
         process.Kill();
     }

src/Cli.Tests/ValidateConfigTests.cs

@@ -199,6 +199,56 @@ public void TestValidateConfigFailsWithNoEntities()
         }
     }
 
+    /// <summary>
+    /// Validates that when the config has no entities or autoentities, TryParseConfig
+    /// sets a clean error message (not a raw exception with stack trace) and
+    /// IsConfigValid returns false without throwing.
+    /// Regression test for https://github.com/Azure/data-api-builder/issues/3268
+    /// </summary>
+    [TestMethod]
+    public void TestValidateConfigWithNoEntitiesProducesCleanError()
+    {
+        string configWithoutEntities = $"{{{SAMPLE_SCHEMA_DATA_SOURCE},{RUNTIME_SECTION}}}";
+
+        // Verify TryParseConfig produces a clean error without stack traces.
+        RuntimeConfigLoader.LastParseError = null;
+
+        StringWriter errorWriter = new();
+        TextWriter originalError = Console.Error;
+        Console.SetError(errorWriter);
+        try
+        {
+            bool parsed = RuntimeConfigLoader.TryParseConfig(configWithoutEntities, out _);
+            Assert.IsFalse(parsed, "Config with no entities should fail to parse.");
+        }
+        finally
+        {
+            Console.SetError(originalError);
+        }
+
+        // LastParseError should contain the clean validation message.
+        Assert.IsNotNull(RuntimeConfigLoader.LastParseError,
+            "LastParseError should be set when config parsing fails.");
+        StringAssert.Contains(RuntimeConfigLoader.LastParseError,
+            "Configuration file should contain either at least the entities or autoentities property",
+            "Parse error should contain the clean validation message.");
+
+        // Console.Error output should be clean (no stack trace, no "Deserialization" wrapper).
+        string stderrOutput = errorWriter.ToString();
+        Assert.IsFalse(stderrOutput.Contains("Stack Trace"),
+            "Stack trace should not be present in stderr output.");
+        Assert.IsFalse(stderrOutput.Contains("Deserialization of the configuration file failed"),
+            "Deserialization wrapper should not appear for DataApiBuilderException errors.");
+        StringAssert.Contains(stderrOutput,
+            "Configuration file should contain either at least the entities or autoentities property",
+            "stderr should show just the clean error message.");
+
+        // Verify IsConfigValid also returns false cleanly (no exception thrown).
+        ((MockFileSystem)_fileSystem!).AddFile(TEST_RUNTIME_CONFIG_FILE, configWithoutEntities);
+        ValidateOptions validateOptions = new(TEST_RUNTIME_CONFIG_FILE);
+        Assert.IsFalse(ConfigGenerator.IsConfigValid(validateOptions, _runtimeConfigLoader!, _fileSystem!));
+    }
+
     /// <summary>
     /// This Test is used to verify that the validate command is able to catch when data source field is missing.
     /// </summary>

src/Cli/Commands/ValidateOptions.cs

@@ -38,7 +38,7 @@ public int Handler(ILogger logger, FileSystemRuntimeConfigLoader loader, IFileSy
             }
             else
             {
-                logger.LogError("Config is invalid. Check above logs for details.");
+                logger.LogInformation("Config is invalid.");
             }
 
             return isValidConfig ? CliReturnCode.SUCCESS : CliReturnCode.GENERAL_ERROR;

src/Cli/ConfigGenerator.cs

@@ -2564,7 +2564,9 @@ 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);
+                string? parseError = RuntimeConfigLoader.LastParseError;
+                RuntimeConfigLoader.LastParseError = null;
+                _logger.LogError("{parseError}", parseError ?? $"Failed to parse the config file: {runtimeConfigFile}.");
                 return false;
             }
             else
@@ -2643,6 +2645,28 @@ public static bool IsConfigValid(ValidateOptions options, FileSystemRuntimeConfi
 
             RuntimeConfigProvider runtimeConfigProvider = new(loader);
 
+            // Suppress Console.Error during config loading so that parse errors
+            // are routed through the CLI's structured logger instead of raw stderr.
+            TextWriter originalError = Console.Error;
+            Console.SetError(TextWriter.Null);
+            bool configLoaded;
+            try
+            {
+                configLoaded = runtimeConfigProvider.TryGetConfig(out RuntimeConfig? _);
+            }
+            finally
+            {
+                Console.SetError(originalError);
+            }
+
+            if (!configLoaded)
+            {
+                string? parseError = RuntimeConfigLoader.LastParseError;
+                RuntimeConfigLoader.LastParseError = null;
+                _logger.LogError("{parseError}", parseError ?? "Failed to parse the config file.");
+                return false;
+            }
+
             ILogger<RuntimeConfigValidator> runtimeConfigValidatorLogger = LoggerFactoryForCli.CreateLogger<RuntimeConfigValidator>();
             RuntimeConfigValidator runtimeConfigValidator = new(runtimeConfigProvider, fileSystem, runtimeConfigValidatorLogger, true);
 

src/Config/RuntimeConfigLoader.cs

@@ -38,6 +38,12 @@ public abstract class RuntimeConfigLoader
 
     public bool IsNewConfigValidated;
 
+    /// <summary>
+    /// Stores the last config parse error message for callers that need
+    /// to retrieve and log it through their own logging infrastructure.
+    /// </summary>
+    public static string? LastParseError { get; set; }
+
     public RuntimeConfigLoader(HotReloadEventHandler<HotReloadEventArgs>? handler = null, string? connectionString = null)
     {
         _changeToken = new DabChangeToken();
@@ -263,17 +269,19 @@ public static bool TryParseConfig(string json,
             ex is JsonException ||
             ex is DataApiBuilderException)
         {
-            string errorMessage = ex is JsonException ? "Deserialization of the configuration file failed." :
-                "Deserialization of the configuration file failed during a post-processing step.";
+            // Store the parse error so callers (e.g. CLI) can retrieve and
+            // log it through their own structured logging infrastructure.
+            LastParseError = ex is DataApiBuilderException
+                ? ex.Message
+                : $"Deserialization of the configuration file failed. {ex.Message}";
 
-            // logger can be null when called from CLI
-            if (logger is null)
+            if (logger is not null)
             {
-                Console.Error.WriteLine(errorMessage + $"\n" + $"Message:\n {ex.Message}\n" + $"Stack Trace:\n {ex.StackTrace}");
+                logger.LogError(exception: ex, message: "{ParseError}", LastParseError);
             }
             else
             {
-                logger.LogError(exception: ex, message: errorMessage);
+                Console.Error.WriteLine(LastParseError);
             }
 
             config = null;

src/Service.Tests/Configuration/RuntimeConfigLoaderTests.cs

@@ -98,8 +98,10 @@ public async Task FailLoadMultiDataSourceConfigDuplicateEntities(string configPa
         loader.TryLoadConfig("dab-config.json", out RuntimeConfig _);
         string error = sw.ToString();
 
-        Assert.IsTrue(error.StartsWith("Deserialization of the configuration file failed during a post-processing step."));
-        Assert.IsTrue(error.Contains("An item with the same key has already been added."));
+        Assert.IsTrue(error.Contains("An item with the same key has already been added."),
+            "Error should contain the specific validation message.");
+        Assert.IsFalse(error.Contains("Stack Trace"),
+            "Stack trace should not be present in error output.");
     }
 
     /// <summary>