Enable Custom log-level for Classes via log-level Filters (#2620)

## Why make this change?

This change solves tasks, #2584, #2585, #2586, #2587, #2588, #2569. 
All of them are part of the bigger task of #2563 which adds filters for
logging.

## What is this change?
This change allows the users to add more specific logging filters to
their config file, this means that log-levels meant for a specific class
will take priority over the default log-level.
In the following example, even if the default is in `debug`, the logging
for `IQueryExecutor` will be in `information`.
```
"Azure.DataApiBuilder.Core.Resolvers.IQueryExecutor": "information",
"default": "debug"
```
Specific Changes:
- Changed the schema file so that it allows for different keywords that
represent the classes, allowing each of them to have a different
log-level. It also allows the user to add a general log-level through
the use of the keyword `default` 
- Updated DAB Validate so that it checks if the keywords used in the
config file are valid classes that we use to give logging information to
the users.
- Change logic that deserializes the new properties in the config file
and stores them inside of the `TelemetryOptions` class and it uses the
saved log-levels to dictate if a specific logger uses a different
log-level from the default. This change gets rid of the `loggerFactory`
and changes it to a dictionary.

## How was this tested?
- [ ] Integration Tests
- [X] Unit Tests

Following tests were added:
- Test that filters are deserialized correctly and their values are what
we expect them to be.
- Test that invalid filters throw an error.
- Test that between two filters, the one that is more specific takes
priority.

## Sample Request(s)

![image](https://github.com/user-attachments/assets/4dbf7a98-7aba-4781-97f3-4b32fa8d77e0)

---------

Co-authored-by: Ruben Cerna <[email protected]>

Author: RubenCerna2079

Diff for: schemas/dab.draft.schema.json

@@ -367,11 +367,11 @@
             },
             "log-level": {
               "type": "object",
-              "description": "Global configuration of log level",
+              "description": "Global configuration of log level, defines logging severity levels for specific classes, when 'null' it will set logging level based on 'host: mode' property",
               "additionalProperties": false,
-              "properties": {
-                "level": {
-                  "description": "Defines logging severity levels, when in default value it will set logging level based on 'host: mode' property",
+              "patternProperties": {
+                "^[a-zA-Z_]\\w{0,}(\\.\\w{1,}){0,}$": {
+                  "description": "Only specific namespaces that are used for logging in DAB are able to be used here. The regex pattern checks that it only allows for namespace values. So it only accepts a letter as its first value, from there it accepts any alphanumeric character, each section is divided by '.' and there cannot be more than 1 '.' in a row",
                   "type": "string",
                   "default": null,
                   "enum": [

Diff for: src/Cli/Commands/ValidateOptions.cs

@@ -4,6 +4,7 @@
 using System.IO.Abstractions;
 using Azure.DataApiBuilder.Config;
 using Azure.DataApiBuilder.Product;
+using Azure.DataApiBuilder.Service;
 using Cli.Constants;
 using CommandLine;
 using Microsoft.Extensions.Logging;
@@ -28,6 +29,7 @@ public ValidateOptions(string config)
         public int Handler(ILogger logger, FileSystemRuntimeConfigLoader loader, IFileSystem fileSystem)
         {
             logger.LogInformation("{productName} {version}", PRODUCT_NAME, ProductInfo.GetProductVersion());
+            Startup.AddValidFilters();
             bool isValidConfig = ConfigGenerator.IsConfigValid(this, loader, fileSystem);
 
             if (isValidConfig)

Diff for: src/Cli/ConfigGenerator.cs

@@ -1672,7 +1672,7 @@ public static bool TryStartEngineWithOptions(StartOptions options, FileSystemRun
             }
             else
             {
-                minimumLogLevel = RuntimeConfig.GetConfiguredLogLevel(deserializedRuntimeConfig);
+                minimumLogLevel = deserializedRuntimeConfig.GetConfiguredLogLevel();
                 HostMode hostModeType = deserializedRuntimeConfig.IsDevelopmentMode() ? HostMode.Development : HostMode.Production;
 
                 _logger.LogInformation("Setting default minimum LogLevel: {minimumLogLevel} for {hostMode} mode.", minimumLogLevel, hostModeType);

Diff for: src/Config/Converters/LogLevelOptionsConverterFactory.cs

@@ -578,11 +578,26 @@ public uint GetPaginationLimit(int? first)
     /// <summary>
     /// Checks if the property log-level or its value are null
     /// </summary>
-    public bool IsLogLevelNull() =>
-        Runtime is null ||
-        Runtime.Telemetry is null ||
-        Runtime.Telemetry.LoggerLevel is null ||
-        Runtime.Telemetry.LoggerLevel.Value is null;
+    public bool IsLogLevelNull()
+    {
+        if (Runtime is null ||
+            Runtime.Telemetry is null ||
+            Runtime.Telemetry.LoggerLevel is null ||
+            Runtime.Telemetry.LoggerLevel.Count == 0)
+        {
+            return true;
+        }
+
+        foreach (KeyValuePair<string, LogLevel?> logger in Runtime!.Telemetry.LoggerLevel)
+        {
+            if (logger.Key == null)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
 
     /// <summary>
     /// Takes in the RuntimeConfig object and checks the LogLevel.
@@ -591,15 +606,37 @@ Runtime.Telemetry.LoggerLevel is null ||
     /// If host mode is Development, return `LogLevel.Debug`, else
     /// for production returns `LogLevel.Error`.
     /// </summary>
-    public static LogLevel GetConfiguredLogLevel(RuntimeConfig runtimeConfig)
+    public LogLevel GetConfiguredLogLevel(string loggerFilter = "")
     {
-        LogLevel? value = runtimeConfig.Runtime?.Telemetry?.LoggerLevel?.Value;
-        if (value is not null)
+
+        if (!IsLogLevelNull())
         {
-            return (LogLevel)value;
+            int max = 0;
+            string currentFilter = string.Empty;
+            foreach (KeyValuePair<string, LogLevel?> logger in Runtime!.Telemetry!.LoggerLevel!)
+            {
+                // Checks if the new key that is valid has more priority than the current key
+                if (logger.Key.Length > max && loggerFilter.StartsWith(logger.Key))
+                {
+                    max = logger.Key.Length;
+                    currentFilter = logger.Key;
+                }
+            }
+
+            Runtime!.Telemetry!.LoggerLevel!.TryGetValue(currentFilter, out LogLevel? value);
+            if (value is not null)
+            {
+                return (LogLevel)value;
+            }
+
+            Runtime!.Telemetry!.LoggerLevel!.TryGetValue("default", out value);
+            if (value is not null)
+            {
+                return (LogLevel)value;
+            }
         }
 
-        if (runtimeConfig.IsDevelopmentMode())
+        if (IsDevelopmentMode())
         {
             return LogLevel.Debug;
         }

Diff for: src/Config/ObjectModel/LogLevelOptions.cs

@@ -2,14 +2,15 @@
 // Licensed under the MIT License.
 
 using System.Text.Json.Serialization;
+using Microsoft.Extensions.Logging;
 
 namespace Azure.DataApiBuilder.Config.ObjectModel;
 
 /// <summary>
 /// Represents the options for telemetry.
 /// </summary>
-public record TelemetryOptions(ApplicationInsightsOptions? ApplicationInsights = null, OpenTelemetryOptions? OpenTelemetry = null, LogLevelOptions? LoggerLevel = null)
+public record TelemetryOptions(ApplicationInsightsOptions? ApplicationInsights = null, OpenTelemetryOptions? OpenTelemetry = null, Dictionary<string, LogLevel?>? LoggerLevel = null)
 {
     [JsonPropertyName("log-level")]
-    public LogLevelOptions? LoggerLevel { get; init; } = LoggerLevel;
+    public Dictionary<string, LogLevel?>? LoggerLevel { get; init; } = LoggerLevel;
 }

Diff for: src/Config/ObjectModel/RuntimeConfig.cs

@@ -248,7 +248,6 @@ public static JsonSerializerOptions GetSerializationOptions(
         options.Converters.Add(new MultipleMutationOptionsConverter(options));
         options.Converters.Add(new DataSourceConverterFactory(replaceEnvVar));
         options.Converters.Add(new HostOptionsConvertorFactory());
-        options.Converters.Add(new LogLevelOptionsConverterFactory());
 
         if (replaceEnvVar)
         {

Diff for: src/Config/ObjectModel/TelemetryOptions.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.DataApiBuilder.Core.Configurations
+{
+    public static class LoggerFilters
+    {
+        public static List<string> validFilters = new();
+
+        public static void AddFilter(string? loggerFilter)
+        {
+            if (loggerFilter != null)
+            {
+                validFilters.Add(loggerFilter);
+            }
+        }
+    }
+}

Diff for: src/Config/RuntimeConfigLoader.cs

@@ -73,6 +73,7 @@ public void ValidateConfigProperties()
         ValidateAuthenticationOptions(runtimeConfig);
         ValidateGlobalEndpointRouteConfig(runtimeConfig);
         ValidateAppInsightsTelemetryConnectionString(runtimeConfig);
+        ValidateLoggerFilters(runtimeConfig);
 
         // Running these graphQL validations only in development mode to ensure
         // fast startup of engine in production mode.
@@ -129,6 +130,25 @@ public void ValidateAppInsightsTelemetryConnectionString(RuntimeConfig runtimeCo
         }
     }
 
+    /// <summary>
+    /// Only certain classes can have different log levels, this function ensures that only those classes are used in the config file.
+    /// </summary>
+    public static void ValidateLoggerFilters(RuntimeConfig runtimeConfig)
+    {
+        if (runtimeConfig.Runtime?.Telemetry is not null && runtimeConfig.Runtime.Telemetry.LoggerLevel is not null)
+        {
+            Dictionary<string, LogLevel?> loggerLevelOptions = runtimeConfig.Runtime.Telemetry.LoggerLevel;
+
+            foreach (KeyValuePair<string, LogLevel?> logger in loggerLevelOptions)
+            {
+                if (!IsLoggerFilterValid(logger.Key))
+                {
+                    throw new NotSupportedException($"Log level filter {logger.Key} needs to be of a valid log class.");
+                }
+            }
+        }
+    }
+
     /// <summary>
     /// This method runs several validations against the config file such as schema validation,
     /// validation of entities metadata, validation of permissions, validation of entity configuration.
@@ -1323,4 +1343,40 @@ private bool IsValidPermissionAction(EntityActionOperation action, Entity entity
             return action is EntityActionOperation.All || EntityAction.ValidPermissionOperations.Contains(action);
         }
     }
+
+    /// <summary>
+    /// Returns whether the log-level keyword is valid or not.
+    /// It does this by checking each section of the name of the class,
+    /// in order to ensure that the last section is complete.
+    /// E.g. Azure.DataApiBuilder is valid. While Azure.DataA is invalid.
+    /// </summary>
+    /// <param name="loggerFilter">String keyword that comes from log-level in config file</param>
+    private static bool IsLoggerFilterValid(string loggerFilter)
+    {
+        string[] loggerSub = loggerFilter.Split('.');
+        for (int i = 0; i < LoggerFilters.validFilters.Count; i++)
+        {
+            bool isValid = true;
+            string[] validFiltersSub = LoggerFilters.validFilters[i].Split('.');
+
+            if (loggerSub.Length <= validFiltersSub.Length)
+            {
+                for (int j = 0; j < loggerSub.Length; j++)
+                {
+                    if (!loggerSub[j].Equals(validFiltersSub[j]))
+                    {
+                        isValid = false;
+                        break;
+                    }
+                }
+
+                if (isValid)
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
 }