Merge branch 'main' into copilot/add-mcp-checks-to-health-endpoint

souvikghosh04 · web-flow · commit 340f6f03e570 · 2026-06-30T11:16:52.000+05:30
diff --git a/CODEOWNERS b/CODEOWNERS
@@ -3,9 +3,9 @@
 # review when someone opens a pull request.
 *       @Aniruddh25 @aaronburtle @anushakolan @jerrynixon @RubenCerna2079 @souvikghosh04 @sourabh1007 @vadeveka @Alekhya-Polavarapu @rusamant @stuartpa
 
-code_of_conduct.md @jerrynixon
-contributing.md @jerrynixon
-license.txt @jerrynixon
-readme.md @jerrynixon
-security.md @jerrynixon
-support.md @jerrynixon
+CODE_OF_CONDUCT.md @jerrynixon @croblesm
+CONTRIBUTING.md @jerrynixon @croblesm
+LICENSE.txt @jerrynixon @croblesm
+README.md @jerrynixon @croblesm
+SECURITY.md @jerrynixon @croblesm
+support.md @jerrynixon @croblesm
diff --git a/src/Cli.Tests/ValidateConfigTests.cs b/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
diff --git a/src/Cli/Commands/ValidateOptions.cs b/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;
diff --git a/src/Cli/ConfigGenerator.cs b/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
diff --git a/src/Core/Configurations/JsonConfigSchemaValidator.cs b/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
diff --git a/src/Core/Configurations/RuntimeConfigValidator.cs b/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
diff --git a/src/Core/Services/MetadataProviders/MsSqlMetadataProvider.cs b/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);
         }
 
diff --git a/src/Core/Services/MetadataProviders/SqlMetadataProvider.cs b/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)
diff --git a/src/Service.Tests/Configuration/ConfigurationTests.cs b/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>

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public int Handler(ILogger logger, FileSystemRuntimeConfigLoader loader, IFileSy`
`38`	`38`	`}`
`39`	`39`	`else`
`40`	`40`	`{`
`41`		`- logger.LogError("Config is invalid.");`
	`41`	`+ logger.LogInformation("Config is invalid.");`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`return isValidConfig ? CliReturnCode.SUCCESS : CliReturnCode.GENERAL_ERROR;`
Original file line number	Diff line number	Diff line change
`@@ -3166,8 +3166,6 @@ public static bool IsConfigValid(ValidateOptions options, FileSystemRuntimeConfi`
`3166`	`3166`	`return false;`
`3167`	`3167`	`}`
`3168`	`3168`
`3169`		`- _logger.LogInformation("Validating config file: {runtimeConfigFile}", runtimeConfigFile);`
`3170`		`-`
`3171`	`3169`	`RuntimeConfigProvider runtimeConfigProvider = new(loader);`
`3172`	`3170`
`3173`	`3171`	`if (!runtimeConfigProvider.TryGetConfig(out RuntimeConfig? _))`
`@@ -3196,14 +3194,21 @@ public static bool IsConfigValid(ValidateOptions options, FileSystemRuntimeConfi`
`3196`	`3194`	`bool mcpEnabled = config.IsMcpEnabled;`
`3197`	`3195`	`if (mcpEnabled)`
`3198`	`3196`	`{`
	`3197`	`+ bool missingFields = false;`
`3199`	`3198`	`foreach (KeyValuePair<string, Entity> entity in config.Entities)`
`3200`	`3199`	`{`
`3201`	`3200`	`if (entity.Value.Fields == null \|\| !entity.Value.Fields.Any())`
`3202`	`3201`	`{`
`3203`		`- _logger.LogWarning($"Entity '{entity.Key}' is missing 'fields' definition while MCP is enabled. " +`
`3204`		`- "It's recommended to define fields explicitly to ensure optimal performance with MCP.");`
	`3202`	`+ missingFields = true;`
	`3203`	`+ _logger.LogDebug($"Entity '{entity.Key}' is missing 'fields' definition while MCP is enabled.");`
`3205`	`3204`	`}`
`3206`	`3205`	`}`
	`3206`	`+`
	`3207`	`+ if (missingFields)`
	`3208`	`+ {`
	`3209`	+ _logger.LogWarning("One or more entities are missing `fields` definition while MCP is enabled. " +
	`3210`	`+ "It's recommended to define fields explicitly to ensure optimal performance with MCP.");`
	`3211`	`+ }`
`3207`	`3212`	`}`
`3208`	`3213`
`3209`	`3214`	`// Warn if Unauthenticated provider is used with authenticated or custom roles`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,6 @@ public JsonSchemaValidationResult ValidateJsonConfigWithSchema(string jsonSchema`
`48`	`48`
`49`	`49`	`if (isValid)`
`50`	`50`	`{`
`51`		`- _logger!.LogInformation("The config satisfies the schema requirements.");`
`52`	`51`	`return new(isValid: true, errors: null);`
`53`	`52`	`}`
`54`	`53`	`else`
Original file line number	Diff line number	Diff line change
`@@ -81,13 +81,19 @@ public override async Task PopulateTriggerMetadataForTable(string entityName, st`
`81`	`81`	`if ("UPDATE".Equals(type_desc))`
`82`	`82`	`{`
`83`	`83`	`sourceDefinition.IsUpdateDMLTriggerEnabled = true;`
`84`		`- _logger.LogInformation($"An update trigger is enabled for the entity: {entityName}");`
	`84`	`+ if (!_isValidateOnly)`
	`85`	`+ {`
	`86`	`+ _logger.LogInformation($"An update trigger is enabled for the entity: {entityName}");`
	`87`	`+ }`
`85`	`88`	`}`
`86`	`89`
`87`	`90`	`if ("INSERT".Equals(type_desc))`
`88`	`91`	`{`
`89`	`92`	`sourceDefinition.IsInsertDMLTriggerEnabled = true;`
`90`		`- _logger.LogInformation($"An insert trigger is enabled for the entity: {entityName}");`
	`93`	`+ if (!_isValidateOnly)`
	`94`	`+ {`
	`95`	`+ _logger.LogInformation($"An insert trigger is enabled for the entity: {entityName}");`
	`96`	`+ }`
`91`	`97`	`}`
`92`	`98`	`}`
`93`	`99`	`}`
`@@ -362,15 +368,6 @@ protected override async Task GenerateAutoentitiesIntoEntities(IReadOnlyDictiona`
`362`	`368`	`subStatusCode: DataApiBuilderException.SubStatusCodes.ErrorInInitialization);`
`363`	`369`	`}`
`364`	`370`
`365`		`- if (runtimeConfig.IsRestEnabled)`
`366`		`- {`
`367`		`- _logger.LogInformation("[{entity}] REST path: {globalRestPath}/{entityRestPath}", entityName, runtimeConfig.RestPath, entityName);`
`368`		`- }`
`369`		`- else`
`370`		`- {`
`371`		`- _logger.LogInformation(message: "REST calls are disabled for the entity: {entity}", entityName);`
`372`		`- }`
`373`		`-`
`374`	`371`	`addedEntities++;`
`375`	`372`	`}`
`376`	`373`
`@@ -383,6 +380,7 @@ protected override async Task GenerateAutoentitiesIntoEntities(IReadOnlyDictiona`
`383`	`380`	`runtimeConfig.AutoentityResolutionCounts[autoentityName] = addedEntities;`
`384`	`381`	`}`
`385`	`382`
	`383`	`+ LogRestPathsForEntities(runtimeConfig, entities);`
`386`	`384`	`_runtimeConfigProvider.AddMergedEntitiesToConfig(entities);`
`387`	`385`	`}`
`388`	`386`