Remove excess logs in dab validate command (#3651)

## Why make this change?

- Solves issue #3266

## What is this change?

Remove excessive logs when the user uses `dab validate`. 
This includes: 
- Removing unnecessary one-liner information logs
- Reducing warning logs so that only more general warnings appear (e.g.
logs related to entities missing `field` descriptions when using MCP)
- Only showing certain relevant information logs when the user uses `dab
start`. All of this is done in order to ensure that the logs in `dab
validate` are not cluttered. (e.g. logs related to REST paths for
entities when enabled)
- Removed logs assertion in tests that used it, as those logs were
removed.

## How was this tested?

- [ ] Integration Tests
- [ ] Unit Tests
- [x] Manual Tests
Tested manually by running `dab validate` and seeing that the logs are
as expected, and ran `dab start` to ensure previous logs didn't change.

## Sample Request(s)

Previous `dab validate` logs:
<img width="959" height="442" alt="image"
src="https://github.com/user-attachments/assets/4d13c362-5e7d-4a82-93a2-0282719b5913"
/>

New `dab validate` logs:
<img width="1469" height="266" alt="image"
src="https://github.com/user-attachments/assets/d15db9be-098c-4e8c-bc6d-6a67e54f6570"
/>

Author: RubenCerna2079

src/Cli.Tests/ValidateConfigTests.cs

@@ -40,6 +40,16 @@ public void TestCleanup()
         Environment.SetEnvironmentVariable($"database-type", null);
         Environment.SetEnvironmentVariable($"sp_param1_int", null);
         Environment.SetEnvironmentVariable($"sp_param2_bool", null);
+
+        // Set output back to the default for other tests.
+        Console.SetOut(new StreamWriter(Console.OpenStandardOutput())
+        {
+            AutoFlush = true
+        });
+        Console.SetError(new StreamWriter(Console.OpenStandardError())
+        {
+            AutoFlush = true
+        });
     }
 
     /// <summary>
@@ -294,9 +304,6 @@ public void ValidateConfigSchemaWhereConfigReferencesEnvironmentVariables()
         Assert.IsFalse(
             condition: loggerOutput.Contains("Failed to validate config against schema due to"),
             message: "Unexpected errors encountered when validating config schema in RuntimeConfigValidator::ValidateConfigSchema(...).");
-        Assert.IsTrue(
-            condition: loggerOutput.Contains("The config satisfies the schema requirements."),
-            message: "RuntimeConfigValidator::ValidateConfigSchema(...) didn't communicate successful config schema validation.");
     }
 
     /// <summary>
@@ -405,6 +412,37 @@ public void TestValidateNonRootZeroEntitiesWithInvalidConnectionString()
         Assert.IsFalse(isValid);
     }
 
+    /// <summary>
+    /// Tests that logs related to suppressed messages do not appear.
+    /// </summary>
+    [TestMethod]
+    public async Task TestValidateSuppressedLogsDoNotAppear()
+    {
+        // Arrange
+        StringWriter writer = new();
+        Console.SetOut(writer);
+
+        string config = AddPropertiesToJson(INITIAL_CONFIG, SINGLE_ENTITY);
+
+        ((MockFileSystem)_fileSystem!).AddFile(
+            path: TEST_RUNTIME_CONFIG_FILE,
+            mockFile: config);
+        ValidateOptions validateOptions = new(TEST_RUNTIME_CONFIG_FILE);
+
+        // Act
+        Utils.LoggerFactoryForCli = Utils.GetLoggerFactoryForCli();
+        ConfigGenerator.IsConfigValid(validateOptions, _runtimeConfigLoader!, _fileSystem!);
+
+        // Assert
+        string loggerOutput = writer.ToString();
+        Assert.IsTrue(
+            condition: !loggerOutput.Contains("REST path:"),
+            message: "RuntimeConfigValidator should not contain any messages indicating REST path for individual entities");
+        Assert.IsTrue(
+            condition: !loggerOutput.Contains("REST calls are disabled for the entity:"),
+            message: "RuntimeConfigValidator should not contain any messages related to REST calls for individual entities");
+    }
+
     /// <summary>
     /// Validates that a root config (with data-source-files pointing to children)
     /// that has no data-source and no entities is considered structurally valid

src/Cli/Commands/ValidateOptions.cs

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

src/Cli/ConfigGenerator.cs

@@ -3166,8 +3166,6 @@ public static bool IsConfigValid(ValidateOptions options, FileSystemRuntimeConfi
                 return false;
             }
 
-            _logger.LogInformation("Validating config file: {runtimeConfigFile}", runtimeConfigFile);
-
             RuntimeConfigProvider runtimeConfigProvider = new(loader);
 
             if (!runtimeConfigProvider.TryGetConfig(out RuntimeConfig? _))
@@ -3196,14 +3194,21 @@ public static bool IsConfigValid(ValidateOptions options, FileSystemRuntimeConfi
                     bool mcpEnabled = config.IsMcpEnabled;
                     if (mcpEnabled)
                     {
+                        bool missingFields = false;
                         foreach (KeyValuePair<string, Entity> entity in config.Entities)
                         {
                             if (entity.Value.Fields == null || !entity.Value.Fields.Any())
                             {
-                                _logger.LogWarning($"Entity '{entity.Key}' is missing 'fields' definition while MCP is enabled. " +
-                                    "It's recommended to define fields explicitly to ensure optimal performance with MCP.");
+                                missingFields = true;
+                                _logger.LogDebug($"Entity '{entity.Key}' is missing 'fields' definition while MCP is enabled.");
                             }
                         }
+
+                        if (missingFields)
+                        {
+                            _logger.LogWarning("One or more entities are missing `fields` definition while MCP is enabled. " +
+                                "It's recommended to define fields explicitly to ensure optimal performance with MCP.");
+                        }
                     }
 
                     // Warn if Unauthenticated provider is used with authenticated or custom roles

src/Core/Configurations/JsonConfigSchemaValidator.cs

@@ -48,7 +48,6 @@ public JsonSchemaValidationResult ValidateJsonConfigWithSchema(string jsonSchema
 
             if (isValid)
             {
-                _logger!.LogInformation("The config satisfies the schema requirements.");
                 return new(isValid: true, errors: null);
             }
             else

src/Core/Configurations/RuntimeConfigValidator.cs

@@ -475,7 +475,6 @@ public async Task<bool> TryValidateConfig(
         ValidateConfigProperties();
         ValidatePermissionsInConfig(runtimeConfig);
 
-        _logger.LogInformation("Validating entity relationships.");
         ValidateRelationshipConfigCorrectness(runtimeConfig);
 
         // This function initializes the metadata providers which in turn validates the connectivity to the

src/Core/Services/MetadataProviders/MsSqlMetadataProvider.cs

@@ -81,13 +81,19 @@ public override async Task PopulateTriggerMetadataForTable(string entityName, st
                 if ("UPDATE".Equals(type_desc))
                 {
                     sourceDefinition.IsUpdateDMLTriggerEnabled = true;
-                    _logger.LogInformation($"An update trigger is enabled for the entity: {entityName}");
+                    if (!_isValidateOnly)
+                    {
+                        _logger.LogInformation($"An update trigger is enabled for the entity: {entityName}");
+                    }
                 }
 
                 if ("INSERT".Equals(type_desc))
                 {
                     sourceDefinition.IsInsertDMLTriggerEnabled = true;
-                    _logger.LogInformation($"An insert trigger is enabled for the entity: {entityName}");
+                    if (!_isValidateOnly)
+                    {
+                        _logger.LogInformation($"An insert trigger is enabled for the entity: {entityName}");
+                    }
                 }
             }
         }
@@ -362,15 +368,6 @@ protected override async Task GenerateAutoentitiesIntoEntities(IReadOnlyDictiona
                             subStatusCode: DataApiBuilderException.SubStatusCodes.ErrorInInitialization);
                     }
 
-                    if (runtimeConfig.IsRestEnabled)
-                    {
-                        _logger.LogInformation("[{entity}] REST path: {globalRestPath}/{entityRestPath}", entityName, runtimeConfig.RestPath, entityName);
-                    }
-                    else
-                    {
-                        _logger.LogInformation(message: "REST calls are disabled for the entity: {entity}", entityName);
-                    }
-
                     addedEntities++;
                 }
 
@@ -383,6 +380,7 @@ protected override async Task GenerateAutoentitiesIntoEntities(IReadOnlyDictiona
                 runtimeConfig.AutoentityResolutionCounts[autoentityName] = addedEntities;
             }
 
+            LogRestPathsForEntities(runtimeConfig, entities);
             _runtimeConfigProvider.AddMergedEntitiesToConfig(entities);
         }
 

src/Core/Services/MetadataProviders/SqlMetadataProvider.cs

@@ -123,18 +123,7 @@ public SqlMetadataProvider(
             _databaseType = runtimeConfig.GetDataSourceFromDataSourceName(dataSourceName).DatabaseType;
             _logger = logger;
             _isValidateOnly = isValidateOnly;
-            foreach ((string entityName, Entity entityMetatdata) in Entities)
-            {
-                if (runtimeConfig.IsRestEnabled)
-                {
-                    string restPath = entityMetatdata.Rest?.Path ?? entityName;
-                    _logger.LogInformation("[{entity}] REST path: {globalRestPath}/{entityRestPath}", entityName, runtimeConfig.RestPath, restPath);
-                }
-                else
-                {
-                    _logger.LogInformation(message: "REST calls are disabled for the entity: {entity}", entityName);
-                }
-            }
+            LogRestPathsForEntities(runtimeConfig, Entities);
 
             ConnectionString = runtimeConfig.GetDataSourceFromDataSourceName(dataSourceName).ConnectionString;
             EntitiesDataSet = new();
@@ -1019,6 +1008,30 @@ protected virtual void PopulateMetadataForLinkingObject(
             return;
         }
 
+        /// <summary>
+        /// Helper method that logs the REST paths for all entities and shows if the REST calls are enabled/disabled for any entity.
+        /// </summary>
+        /// <param name="runtimeConfig"></param>
+        /// <param name="entities"></param>
+        protected void LogRestPathsForEntities(RuntimeConfig runtimeConfig, IReadOnlyDictionary<string, Entity> entities)
+        {
+            if (!_isValidateOnly)
+            {
+                foreach ((string entityName, Entity entityMetatdata) in entities)
+                {
+                    if (runtimeConfig.IsRestEnabled)
+                    {
+                        string restPath = entityMetatdata.Rest?.Path ?? entityName;
+                        _logger.LogInformation("[{entity}] REST path: {globalRestPath}/{entityRestPath}", entityName, runtimeConfig.RestPath, restPath);
+                    }
+                    else
+                    {
+                        _logger.LogInformation(message: "REST calls are disabled for the entity: {entity}", entityName);
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Adds a new foreign key definition for the target entity in the relationship metadata.
         /// The last argument "relationshipData" is modified (hydrated with the new foreign key definition)

src/Service.Tests/Configuration/ConfigurationTests.cs

@@ -1856,7 +1856,6 @@ public async Task TestSqlMetadataValidationForEntitiesWithInvalidSource()
         /// <summary>
         /// This test method validates a sample DAB runtime config file against DAB's JSON schema definition.
         /// It asserts that the validation is successful and there are no validation failures.
-        /// It also verifies that the expected log message is logged.
         /// </summary>
         [TestMethod("Validates the config file schema."), TestCategory(TestCategory.MSSQL)]
         public void TestConfigSchemaIsValid()
@@ -1874,20 +1873,11 @@ public void TestConfigSchemaIsValid()
             JsonSchemaValidationResult result = jsonSchemaValidator.ValidateJsonConfigWithSchema(jsonSchema, jsonData);
             Assert.IsTrue(result.IsValid);
             Assert.IsTrue(EnumerableUtilities.IsNullOrEmpty(result.ValidationErrors));
-            schemaValidatorLogger.Verify(
-                x => x.Log(
-                    LogLevel.Information,
-                    It.IsAny<EventId>(),
-                    It.Is<It.IsAnyType>((o, t) => o.ToString()!.Contains($"The config satisfies the schema requirements.")),
-                    It.IsAny<Exception>(),
-                    (Func<It.IsAnyType, Exception, string>)It.IsAny<object>()),
-                Times.Once);
         }
 
         /// <summary>
         /// This test method validates a sample DAB runtime config file against DAB's JSON schema definition.
         /// It asserts that the validation is successful and there are no validation failures when no optional fields are used.
-        /// It also verifies that the expected log message is logged.
         /// </summary>
         [DataTestMethod]
         [DataRow(CONFIG_FILE_WITH_NO_OPTIONAL_FIELD, DisplayName = "Validates schema of the config file with no optional fields.")]
@@ -1906,14 +1896,6 @@ public void TestBasicConfigSchemaWithNoOptionalFieldsIsValid(string jsonData)
             Assert.IsTrue(EnumerableUtilities.IsNullOrEmpty(result.ValidationErrors));
 
             Assert.IsTrue(result.IsValid);
-            schemaValidatorLogger.Verify(
-                x => x.Log(
-                    LogLevel.Information,
-                    It.IsAny<EventId>(),
-                    It.Is<It.IsAnyType>((o, t) => o.ToString()!.Contains($"The config satisfies the schema requirements.")),
-                    It.IsAny<Exception>(),
-                    (Func<It.IsAnyType, Exception, string>)It.IsAny<object>()),
-                Times.Once);
         }
 
         [DataTestMethod]
@@ -1940,14 +1922,6 @@ public void TestBasicConfigSchemaWithFlexibleBoolean(string Value)
             Assert.IsTrue(EnumerableUtilities.IsNullOrEmpty(result.ValidationErrors), "Validation Erros null of empty");
 
             Assert.IsTrue(result.IsValid, "Result should be valid");
-            schemaValidatorLogger.Verify(
-                x => x.Log(
-                    LogLevel.Information,
-                    It.IsAny<EventId>(),
-                    It.Is<It.IsAnyType>((o, t) => o.ToString()!.Contains($"The config satisfies the schema requirements.")),
-                    It.IsAny<Exception>(),
-                    (Func<It.IsAnyType, Exception, string>)It.IsAny<object>()),
-                Times.Once);
         }
 
         /// <summary>