Adding 'Configure' Options to CLI for Azure Log Analytics (#2781)

## Why make this change?

This change closes issue #2777

## What is this change?

This change extends the functionality of the `configure` CLI command by
introducing support for Azure Log Analytics properties. With this
enhancement, users can now configure the Azure Log Analytics properties
inside of their config file without the need to directly edit it.
This change also ensures that the validation of Azure Log Analytics
works as intended.

## How was this tested?

- [ ] Integration Tests
- [X] Unit Tests

## Sample Request(s)

CLI Updates
Add support to dab configure:

dab configure --runtime.telemetry.azure-log-analytics.enabled
dab configure --runtime.telemetry.azure-log-analytics.auth.workspace-id
dab configure
--runtime.telemetry.azure-log-analytics.auth.dcr-immutable-id
dab configure --runtime.telemetry.azure-log-analytics.auth.dce-endpoint
dab configure --runtime.telemetry.azure-log-analytics.log-type
dab configure
--runtime.telemetry.azure-log-analytics.flush-interval-seconds

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: aaronburtle <[email protected]>

Author: 3 people

src/Cli.Tests/ConfigureOptionsTests.cs

@@ -148,6 +148,46 @@ public void TestAddAKVOptions()
             Assert.AreEqual(1, config.AzureKeyVault?.RetryPolicy.NetworkTimeoutSeconds);
         }
 
+        /// <summary>
+        /// Tests that running the "configure --azure-log-analytics" commands on a config without Azure Log Analytics properties results
+        /// in a valid config being generated.
+        [TestMethod]
+        public void TestAddAzureLogAnalyticsOptions()
+        {
+            // Arrange
+            _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(INITIAL_CONFIG));
+
+            Assert.IsTrue(_fileSystem!.File.Exists(TEST_RUNTIME_CONFIG_FILE));
+
+            // Act: Attempts to add Azure Log Analytics options
+            ConfigureOptions options = new(
+                azureLogAnalyticsEnabled: CliBool.True,
+                azureLogAnalyticsLogType: "log-type-test",
+                azureLogAnalyticsFlushIntervalSeconds: 1,
+                azureLogAnalyticsWorkspaceId: "workspace-id-test",
+                azureLogAnalyticsDcrImmutableId: "dcr-immutable-id-test",
+                azureLogAnalyticsDceEndpoint: "dce-endpoint-test",
+                config: TEST_RUNTIME_CONFIG_FILE
+            );
+
+            bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);
+
+            // Assert: Validate the Azure Log Analytics options are added.
+            Assert.IsTrue(isSuccess);
+            string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
+            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
+            Assert.IsNotNull(config.Runtime);
+            Assert.IsNotNull(config.Runtime.Telemetry);
+            Assert.IsNotNull(config.Runtime.Telemetry.AzureLogAnalytics);
+            Assert.AreEqual(true, config.Runtime.Telemetry.AzureLogAnalytics.Enabled);
+            Assert.AreEqual("log-type-test", config.Runtime.Telemetry.AzureLogAnalytics.LogType);
+            Assert.AreEqual(1, config.Runtime.Telemetry.AzureLogAnalytics.FlushIntervalSeconds);
+            Assert.IsNotNull(config.Runtime.Telemetry.AzureLogAnalytics.Auth);
+            Assert.AreEqual("workspace-id-test", config.Runtime.Telemetry.AzureLogAnalytics.Auth.WorkspaceId);
+            Assert.AreEqual("dcr-immutable-id-test", config.Runtime.Telemetry.AzureLogAnalytics.Auth.DcrImmutableId);
+            Assert.AreEqual("dce-endpoint-test", config.Runtime.Telemetry.AzureLogAnalytics.Auth.DceEndpoint);
+        }
+
         /// <summary>
         /// Tests that running "dab configure --runtime.graphql.enabled" on a config with various values results
         /// in runtime. Takes in updated value for graphql.enabled and 

src/Cli.Tests/ValidateConfigTests.cs

@@ -311,4 +311,39 @@ public async Task TestValidateAKVOptionsWithoutEndpointFails()
         JsonSchemaValidationResult result = await validator.ValidateConfigSchema(config, TEST_RUNTIME_CONFIG_FILE, mockLoggerFactory.Object);
         Assert.IsFalse(result.IsValid);
     }
+
+    /// <summary>
+    /// Tests that validation fails when Azure Log Analytics options are configured without the Auth options.
+    /// </summary>
+    [TestMethod]
+    public async Task TestValidateAzureLogAnalyticsOptionsWithoutAuthFails()
+    {
+        // Arrange
+        _fileSystem!.AddFile(TEST_RUNTIME_CONFIG_FILE, new MockFileData(INITIAL_CONFIG));
+        Assert.IsTrue(_fileSystem!.File.Exists(TEST_RUNTIME_CONFIG_FILE));
+        Mock<RuntimeConfigProvider> mockRuntimeConfigProvider = new(_runtimeConfigLoader);
+        RuntimeConfigValidator validator = new(mockRuntimeConfigProvider.Object, _fileSystem, new Mock<ILogger<RuntimeConfigValidator>>().Object);
+        Mock<ILoggerFactory> mockLoggerFactory = new();
+        Mock<ILogger<JsonConfigSchemaValidator>> mockLogger = new();
+        mockLoggerFactory
+            .Setup(factory => factory.CreateLogger(typeof(JsonConfigSchemaValidator).FullName!))
+            .Returns(mockLogger.Object);
+
+        // Act: Attempts to add Azure Log Analytics options without Auth options
+        ConfigureOptions options = new(
+            azureLogAnalyticsEnabled: CliBool.True,
+            azureLogAnalyticsLogType: "log-type-test",
+            azureLogAnalyticsFlushIntervalSeconds: 1,
+            config: TEST_RUNTIME_CONFIG_FILE
+        );
+
+        bool isSuccess = TryConfigureSettings(options, _runtimeConfigLoader!, _fileSystem!);
+
+        // Assert: Settings are configured, config parses, validation fails.
+        Assert.IsTrue(isSuccess);
+        string updatedConfig = _fileSystem!.File.ReadAllText(TEST_RUNTIME_CONFIG_FILE);
+        Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(updatedConfig, out RuntimeConfig? config));
+        JsonSchemaValidationResult result = await validator.ValidateConfigSchema(config, TEST_RUNTIME_CONFIG_FILE, mockLoggerFactory.Object);
+        Assert.IsFalse(result.IsValid);
+    }
 }

src/Cli/Commands/ConfigureOptions.cs

@@ -48,6 +48,12 @@ public ConfigureOptions(
             int? azureKeyVaultRetryPolicyDelaySeconds = null,
             int? azureKeyVaultRetryPolicyMaxDelaySeconds = null,
             int? azureKeyVaultRetryPolicyNetworkTimeoutSeconds = null,
+            CliBool? azureLogAnalyticsEnabled = null,
+            string? azureLogAnalyticsLogType = null,
+            int? azureLogAnalyticsFlushIntervalSeconds = null,
+            string? azureLogAnalyticsWorkspaceId = null,
+            string? azureLogAnalyticsDcrImmutableId = null,
+            string? azureLogAnalyticsDceEndpoint = null,
             string? config = null)
             : base(config)
         {
@@ -85,6 +91,13 @@ public ConfigureOptions(
             AzureKeyVaultRetryPolicyDelaySeconds = azureKeyVaultRetryPolicyDelaySeconds;
             AzureKeyVaultRetryPolicyMaxDelaySeconds = azureKeyVaultRetryPolicyMaxDelaySeconds;
             AzureKeyVaultRetryPolicyNetworkTimeoutSeconds = azureKeyVaultRetryPolicyNetworkTimeoutSeconds;
+            // Azure Log Analytics
+            AzureLogAnalyticsEnabled = azureLogAnalyticsEnabled;
+            AzureLogAnalyticsLogType = azureLogAnalyticsLogType;
+            AzureLogAnalyticsFlushIntervalSeconds = azureLogAnalyticsFlushIntervalSeconds;
+            AzureLogAnalyticsWorkspaceId = azureLogAnalyticsWorkspaceId;
+            AzureLogAnalyticsDcrImmutableId = azureLogAnalyticsDcrImmutableId;
+            AzureLogAnalyticsDceEndpoint = azureLogAnalyticsDceEndpoint;
         }
 
         [Option("data-source.database-type", Required = false, HelpText = "Database type. Allowed values: MSSQL, PostgreSQL, CosmosDB_NoSQL, MySQL.")]
@@ -171,6 +184,24 @@ public ConfigureOptions(
         [Option("azure-key-vault.retry-policy.network-timeout-seconds", Required = false, HelpText = "Configure the network timeout for requests in seconds. Default: 60.")]
         public int? AzureKeyVaultRetryPolicyNetworkTimeoutSeconds { get; }
 
+        [Option("runtime.telemetry.azure-log-analytics.enabled", Default = CliBool.False, Required = false, HelpText = "Enable/Disable Azure Log Analytics.")]
+        public CliBool? AzureLogAnalyticsEnabled { get; }
+
+        [Option("runtime.telemetry.azure-log-analytics.log-type", Required = false, HelpText = "Configure Log Type for Azure Log Analytics to find table to send telemetry data")]
+        public string? AzureLogAnalyticsLogType { get; }
+
+        [Option("runtime.telemetry.azure-log-analytics.flush-interval-seconds", Required = false, HelpText = "Configure Flush Interval in seconds for Azure Log Analytics to specify the time interval to send the telemetry data")]
+        public int? AzureLogAnalyticsFlushIntervalSeconds { get; }
+
+        [Option("runtime.telemetry.azure-log-analytics.auth.workspace-id", Required = false, HelpText = "Configure Workspace ID for Azure Log Analytics used to find workspace to connect")]
+        public string? AzureLogAnalyticsWorkspaceId { get; }
+
+        [Option("runtime.telemetry.azure-log-analytics.auth.dcr-immutable-id", Required = false, HelpText = "Configure DCR Immutable ID for Azure Log Analytics to find the data collection rule that defines how data is collected")]
+        public string? AzureLogAnalyticsDcrImmutableId { get; }
+
+        [Option("runtime.telemetry.azure-log-analytics.auth.dce-endpoint", Required = false, HelpText = "Configure DCE Endpoint for Azure Log Analytics to find table to send telemetry data")]
+        public string? AzureLogAnalyticsDceEndpoint { get; }
+
         public int Handler(ILogger logger, FileSystemRuntimeConfigLoader loader, IFileSystem fileSystem)
         {
             logger.LogInformation("{productName} {version}", PRODUCT_NAME, ProductInfo.GetProductVersion());

src/Cli/ConfigGenerator.cs

@@ -778,6 +778,26 @@ private static bool TryUpdateConfiguredRuntimeOptions(
                 }
             }
 
+            // Telemetry: Azure Log Analytics
+            if (options.AzureLogAnalyticsEnabled is not null ||
+                options.AzureLogAnalyticsLogType is not null ||
+                options.AzureLogAnalyticsFlushIntervalSeconds is not null ||
+                options.AzureLogAnalyticsWorkspaceId is not null ||
+                options.AzureLogAnalyticsDcrImmutableId is not null ||
+                options.AzureLogAnalyticsDceEndpoint is not null)
+            {
+                AzureLogAnalyticsOptions updatedAzureLogAnalyticsOptions = runtimeConfig?.Runtime?.Telemetry?.AzureLogAnalytics ?? new();
+                bool status = TryUpdateConfiguredAzureLogAnalyticsOptions(options, ref updatedAzureLogAnalyticsOptions);
+                if (status)
+                {
+                    runtimeConfig = runtimeConfig! with { Runtime = runtimeConfig.Runtime! with { Telemetry = runtimeConfig.Runtime!.Telemetry is not null ? runtimeConfig.Runtime!.Telemetry with { AzureLogAnalytics = updatedAzureLogAnalyticsOptions } : new TelemetryOptions(AzureLogAnalytics: updatedAzureLogAnalyticsOptions) } };
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
             return runtimeConfig != null;
         }
 
@@ -844,7 +864,7 @@ private static bool TryUpdateConfiguredRestValues(ConfigureOptions options, ref
         /// </summary>
         /// <param name="options">options.</param>
         /// <param name="updatedGraphQLOptions">updatedGraphQLOptions.</param>
-        /// <returns>True if the value needs to be udpated in the runtime config, else false</returns>
+        /// <returns>True if the value needs to be updated in the runtime config, else false</returns>
         private static bool TryUpdateConfiguredGraphQLValues(
             ConfigureOptions options,
             ref GraphQLRuntimeOptions? updatedGraphQLOptions)
@@ -910,7 +930,7 @@ private static bool TryUpdateConfiguredGraphQLValues(
         /// </summary>
         /// <param name="options">options.</param>
         /// <param name="updatedCacheOptions">updatedCacheOptions.</param>
-        /// <returns>True if the value needs to be udpated in the runtime config, else false</returns>
+        /// <returns>True if the value needs to be updated in the runtime config, else false</returns>
         private static bool TryUpdateConfiguredCacheValues(
             ConfigureOptions options,
             ref RuntimeCacheOptions? updatedCacheOptions)
@@ -959,7 +979,7 @@ private static bool TryUpdateConfiguredCacheValues(
         /// </summary>
         /// <param name="options">options.</param>
         /// <param name="updatedHostOptions">updatedHostOptions.</param>
-        /// <returns>True if the value needs to be udpated in the runtime config, else false</returns>
+        /// <returns>True if the value needs to be updated in the runtime config, else false</returns>
         private static bool TryUpdateConfiguredHostValues(
             ConfigureOptions options,
             ref HostOptions? updatedHostOptions)
@@ -1095,6 +1115,90 @@ private static bool TryUpdateConfiguredHostValues(
             }
         }
 
+        /// <summary>
+        /// Attempts to update the Azure Log Analytics configuration options based on the provided values.
+        /// Validates that any user-provided parameter value is valid and updates the runtime configuration accordingly.
+        /// </summary>
+        /// <param name="options">The configuration options provided by the user.</param>
+        /// <param name="azureLogAnalyticsOptions">The Azure Log Analytics options to be updated.</param>
+        /// <returns>True if the Azure Log Analytics options were successfully configured; otherwise, false.</returns>
+        private static bool TryUpdateConfiguredAzureLogAnalyticsOptions(
+            ConfigureOptions options,
+            ref AzureLogAnalyticsOptions azureLogAnalyticsOptions)
+        {
+            try
+            {
+                AzureLogAnalyticsAuthOptions? updatedAuthOptions = azureLogAnalyticsOptions.Auth;
+
+                // Runtime.Telemetry.AzureLogAnalytics.Enabled
+                if (options.AzureLogAnalyticsEnabled is not null)
+                {
+                    azureLogAnalyticsOptions = azureLogAnalyticsOptions with { Enabled = options.AzureLogAnalyticsEnabled is CliBool.True, UserProvidedEnabled = true };
+                    _logger.LogInformation($"Updated configuration with runtime.telemetry.azure-log-analytics.enabled as '{options.AzureLogAnalyticsEnabled}'");
+                }
+
+                // Runtime.Telemetry.AzureLogAnalytics.LogType
+                if (options.AzureLogAnalyticsLogType is not null)
+                {
+                    azureLogAnalyticsOptions = azureLogAnalyticsOptions with { LogType = options.AzureLogAnalyticsLogType, UserProvidedLogType = true };
+                    _logger.LogInformation($"Updated configuration with runtime.telemetry.azure-log-analytics.log-type as '{options.AzureLogAnalyticsLogType}'");
+                }
+
+                // Runtime.Telemetry.AzureLogAnalytics.FlushIntervalSeconds
+                if (options.AzureLogAnalyticsFlushIntervalSeconds is not null)
+                {
+                    if (options.AzureLogAnalyticsFlushIntervalSeconds <= 0)
+                    {
+                        _logger.LogError("Failed to update configuration with runtime.telemetry.azure-log-analytics.flush-interval-seconds. Value must be a positive integer greater than 0.");
+                        return false;
+                    }
+
+                    azureLogAnalyticsOptions = azureLogAnalyticsOptions with { FlushIntervalSeconds = options.AzureLogAnalyticsFlushIntervalSeconds, UserProvidedFlushIntervalSeconds = true };
+                    _logger.LogInformation($"Updated configuration with runtime.telemetry.azure-log-analytics.flush-interval-seconds as '{options.AzureLogAnalyticsFlushIntervalSeconds}'");
+                }
+
+                // Runtime.Telemetry.AzureLogAnalytics.Auth.WorkspaceId
+                if (options.AzureLogAnalyticsWorkspaceId is not null)
+                {
+                    updatedAuthOptions = updatedAuthOptions is not null
+                        ? updatedAuthOptions with { WorkspaceId = options.AzureLogAnalyticsWorkspaceId, UserProvidedWorkspaceId = true }
+                        : new AzureLogAnalyticsAuthOptions { WorkspaceId = options.AzureLogAnalyticsWorkspaceId, UserProvidedWorkspaceId = true };
+                    _logger.LogInformation($"Updated configuration with runtime.telemetry.azure-log-analytics.auth.workspace-id as '{options.AzureLogAnalyticsWorkspaceId}'");
+                }
+
+                // Runtime.Telemetry.AzureLogAnalytics.Auth.DcrImmutableId
+                if (options.AzureLogAnalyticsDcrImmutableId is not null)
+                {
+                    updatedAuthOptions = updatedAuthOptions is not null
+                        ? updatedAuthOptions with { DcrImmutableId = options.AzureLogAnalyticsDcrImmutableId, UserProvidedDcrImmutableId = true }
+                        : new AzureLogAnalyticsAuthOptions { DcrImmutableId = options.AzureLogAnalyticsDcrImmutableId, UserProvidedDcrImmutableId = true };
+                    _logger.LogInformation($"Updated configuration with runtime.telemetry.azure-log-analytics.auth.dcr-immutable-id as '{options.AzureLogAnalyticsDcrImmutableId}'");
+                }
+
+                // Runtime.Telemetry.AzureLogAnalytics.Auth.DceEndpoint
+                if (options.AzureLogAnalyticsDceEndpoint is not null)
+                {
+                    updatedAuthOptions = updatedAuthOptions is not null
+                        ? updatedAuthOptions with { DceEndpoint = options.AzureLogAnalyticsDceEndpoint, UserProvidedDceEndpoint = true }
+                        : new AzureLogAnalyticsAuthOptions { DceEndpoint = options.AzureLogAnalyticsDceEndpoint, UserProvidedDceEndpoint = true };
+                    _logger.LogInformation($"Updated configuration with runtime.telemetry.azure-log-analytics.auth.dce-endpoint as '{options.AzureLogAnalyticsDceEndpoint}'");
+                }
+
+                // Update Azure Log Analytics options with Auth options if it was modified
+                if (updatedAuthOptions is not null)
+                {
+                    azureLogAnalyticsOptions = azureLogAnalyticsOptions with { Auth = updatedAuthOptions };
+                }
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"Failed to update configuration with runtime.telemetry.azure-log-analytics. Exception message: {ex.Message}.");
+                return false;
+            }
+        }
+
         /// <summary>
         /// Parse permission string to create PermissionSetting array.
         /// </summary>

src/Config/Converters/AzureLogAnalyticsAuthOptionsConverter.cs

@@ -73,7 +73,6 @@ public AzureLogAnalyticsAuthOptionsConverter(bool replaceEnvVar)
                         throw new JsonException($"Unexpected property {propertyName}");
                 }
             }
-
         }
 
         throw new JsonException("Failed to read the Azure Log Analytics Auth Options");

src/Config/Converters/AzureLogAnalyticsOptionsConverterFactory.cs

@@ -141,7 +141,7 @@ public override void Write(Utf8JsonWriter writer, AzureLogAnalyticsOptions value
                 JsonSerializer.Serialize(writer, value.Enabled, options);
             }
 
-            if (value?.Auth is not null)
+            if (value?.Auth is not null && (value.Auth.UserProvidedWorkspaceId || value.Auth.UserProvidedDcrImmutableId || value.Auth.UserProvidedDceEndpoint))
             {
                 AzureLogAnalyticsAuthOptionsConverter authOptionsConverter = options.GetConverter(typeof(AzureLogAnalyticsAuthOptions)) as AzureLogAnalyticsAuthOptionsConverter ??
                                     throw new JsonException("Failed to get azure-log-analytics.auth options converter");