feat: Create NetEvolve.HealthChecks.Azure.Kusto project with basic implementation

Co-authored-by: samtrion <[email protected]>

Author: Copilot

Directory.Packages.props

@@ -26,6 +26,7 @@
     <PackageVersion Include="AWSSDK.SQS" Version="4.0.1.5" />
     <PackageVersion Include="Azure.Data.Tables" Version="12.11.0" />
     <PackageVersion Include="Azure.Identity" Version="1.16.0" />
+    <PackageVersion Include="Microsoft.Azure.Kusto.Data" Version="12.2.3" />
     <PackageVersion Include="Azure.Messaging.ServiceBus" Version="7.20.1" />
     <PackageVersion Include="Azure.Storage.Blobs" Version="12.25.1" />
     <PackageVersion Include="Azure.Storage.Queues" Version="12.23.0" />

src/NetEvolve.HealthChecks.Azure.Kusto/ClientCreation.cs

@@ -0,0 +1,61 @@
+namespace NetEvolve.HealthChecks.Azure.Kusto;
+
+using System;
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using Azure.Core;
+using Azure.Identity;
+using Kusto.Data.Common;
+using Kusto.Data.Net.Client;
+using Microsoft.Extensions.DependencyInjection;
+
+internal class ClientCreation
+{
+    private ConcurrentDictionary<string, ICslQueryProvider>? _kustoClients;
+
+    internal ICslQueryProvider GetKustoClient<TOptions>(string name, TOptions options, IServiceProvider serviceProvider)
+        where TOptions : class, IKustoOptions
+    {
+        if (options.Mode == KustoClientCreationMode.ServiceProvider)
+        {
+            return serviceProvider.GetRequiredService<ICslQueryProvider>();
+        }
+
+        if (_kustoClients is null)
+        {
+            _kustoClients = new ConcurrentDictionary<string, ICslQueryProvider>(StringComparer.OrdinalIgnoreCase);
+        }
+
+        return _kustoClients.GetOrAdd(name, _ => CreateKustoClient(options, serviceProvider));
+    }
+
+    internal static ICslQueryProvider CreateKustoClient<TOptions>(TOptions options, IServiceProvider serviceProvider)
+        where TOptions : class, IKustoOptions
+    {
+        KustoConnectionStringBuilder connectionStringBuilder;
+
+#pragma warning disable IDE0010 // Add missing cases
+        switch (options.Mode)
+        {
+            case KustoClientCreationMode.DefaultAzureCredentials:
+                var tokenCredential = serviceProvider.GetService<TokenCredential>() ?? new DefaultAzureCredential();
+                connectionStringBuilder = new KustoConnectionStringBuilder(
+                    options.ClusterUri!.ToString()
+                ).WithAadUserPromptAuthentication();
+                break;
+            case KustoClientCreationMode.ConnectionString:
+                connectionStringBuilder = new KustoConnectionStringBuilder(options.ConnectionString);
+                break;
+            default:
+                throw new UnreachableException($"Invalid client creation mode `{options.Mode}`.");
+        }
+#pragma warning restore IDE0010 // Add missing cases
+
+        if (options.ConfigureConnectionStringBuilder is not null)
+        {
+            options.ConfigureConnectionStringBuilder(connectionStringBuilder);
+        }
+
+        return KustoClientFactory.CreateCslQueryProvider(connectionStringBuilder);
+    }
+}

src/NetEvolve.HealthChecks.Azure.Kusto/DependencyInjectionExtensions.cs

@@ -0,0 +1,66 @@
+namespace NetEvolve.HealthChecks.Azure.Kusto;
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using NetEvolve.HealthChecks.Abstractions;
+
+/// <summary>
+/// Extensions methods for <see cref="IHealthChecksBuilder"/> with custom Health Checks.
+/// </summary>
+public static class DependencyInjectionExtensions
+{
+    private static readonly string[] _defaultTags = ["azure", "kusto", "data", "analytics"];
+
+    /// <summary>
+    /// Adds a health check for Azure Kusto (Data Explorer), to check the cluster connectivity and optionally database availability.
+    /// </summary>
+    /// <param name="builder">The <see cref="IHealthChecksBuilder"/>.</param>
+    /// <param name="name">The name of the <see cref="KustoHealthCheck"/>.</param>
+    /// <param name="options">An optional action to configure.</param>
+    /// <param name="tags">A list of additional tags that can be used to filter sets of health checks. Optional.</param>
+    /// <exception cref="ArgumentNullException">The <paramref name="builder"/> is <see langword="null" />.</exception>
+    /// <exception cref="ArgumentNullException">The <paramref name="name"/> is <see langword="null" />.</exception>
+    /// <exception cref="ArgumentException">The <paramref name="name"/> is <see langword="null" /> or <c>whitespace</c>.</exception>
+    /// <exception cref="ArgumentException">The <paramref name="name"/> is already in use.</exception>
+    /// <exception cref="ArgumentNullException">The <paramref name="tags"/> is <see langword="null" />.</exception>
+    public static IHealthChecksBuilder AddKusto(
+        [NotNull] this IHealthChecksBuilder builder,
+        [NotNull] string name,
+        Action<KustoOptions>? options = null,
+        params string[] tags
+    )
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentException.ThrowIfNullOrEmpty(name);
+        ArgumentNullException.ThrowIfNull(tags);
+
+        if (!builder.IsServiceTypeRegistered<AzureKustoCheckMarker>())
+        {
+            _ = builder
+                .Services.AddSingleton<AzureKustoCheckMarker>()
+                .AddSingleton<KustoHealthCheck>()
+                .ConfigureOptions<KustoConfigure>();
+
+            builder.Services.TryAddSingleton<ClientCreation>();
+        }
+
+        builder.ThrowIfNameIsAlreadyUsed<KustoHealthCheck>(name);
+
+        if (options is not null)
+        {
+            _ = builder.Services.Configure(name, options);
+        }
+
+        return builder.AddCheck<KustoHealthCheck>(
+            name,
+            HealthStatus.Unhealthy,
+            _defaultTags.Union(tags, StringComparer.OrdinalIgnoreCase)
+        );
+    }
+
+    private sealed partial class AzureKustoCheckMarker;
+}

src/NetEvolve.HealthChecks.Azure.Kusto/IKustoOptions.cs

@@ -0,0 +1,19 @@
+namespace NetEvolve.HealthChecks.Azure.Kusto;
+
+using System;
+using Kusto.Data.Common;
+
+internal interface IKustoOptions
+{
+    string? ConnectionString { get; }
+
+    Uri? ClusterUri { get; }
+
+    string? DatabaseName { get; }
+
+    KustoClientCreationMode? Mode { get; }
+
+    Action<KustoConnectionStringBuilder>? ConfigureConnectionStringBuilder { get; }
+
+    int Timeout { get; }
+}

src/NetEvolve.HealthChecks.Azure.Kusto/KustoClientCreationMode.cs

@@ -0,0 +1,25 @@
+namespace NetEvolve.HealthChecks.Azure.Kusto;
+
+using System;
+using Kusto.Data.Common;
+
+/// <summary>
+/// Describes the mode used to create the Kusto client.
+/// </summary>
+public enum KustoClientCreationMode
+{
+    /// <summary>
+    /// The default mode. The Kusto client is loading the preregistered instance from the <see cref="IServiceProvider"/>.
+    /// </summary>
+    ServiceProvider = 0,
+
+    /// <summary>
+    /// The Kusto client is created using the <see cref="KustoOptions.ConnectionString"/>.
+    /// </summary>
+    ConnectionString = 1,
+
+    /// <summary>
+    /// The Kusto client is created using Azure AD authentication with default credentials.
+    /// </summary>
+    DefaultAzureCredentials = 2,
+}

src/NetEvolve.HealthChecks.Azure.Kusto/KustoConfigure.cs

@@ -0,0 +1,100 @@
+namespace NetEvolve.HealthChecks.Azure.Kusto;
+
+using System;
+using System.Threading;
+using Kusto.Data.Net.Client;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using static Microsoft.Extensions.Options.ValidateOptionsResult;
+
+internal sealed class KustoConfigure : IConfigureNamedOptions<KustoOptions>, IValidateOptions<KustoOptions>
+{
+    private readonly IConfiguration _configuration;
+    private readonly IServiceProvider _serviceProvider;
+
+    public KustoConfigure(IConfiguration configuration, IServiceProvider serviceProvider)
+    {
+        _configuration = configuration;
+        _serviceProvider = serviceProvider;
+    }
+
+    public void Configure(string? name, KustoOptions options)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(name);
+        _configuration.Bind($"HealthChecks:AzureKusto:{name}", options);
+    }
+
+    public void Configure(KustoOptions options) => Configure(Options.DefaultName, options);
+
+    public ValidateOptionsResult Validate(string? name, KustoOptions options)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            return Fail("The name cannot be null or whitespace.");
+        }
+
+        if (options is null)
+        {
+            return Fail("The option cannot be null.");
+        }
+
+        if (options.Timeout < Timeout.Infinite)
+        {
+            return Fail("The timeout value must be a positive number in milliseconds or -1 for an infinite timeout.");
+        }
+
+        var mode = options.Mode;
+
+        return options.Mode switch
+        {
+            KustoClientCreationMode.ServiceProvider => ValidateModeServiceProvider(),
+            KustoClientCreationMode.ConnectionString => ValidateModeConnectionString(options),
+            KustoClientCreationMode.DefaultAzureCredentials => ValidateModeDefaultAzureCredentials(options),
+            _ => Fail($"The mode `{mode}` is not supported."),
+        };
+    }
+
+    private static ValidateOptionsResult ValidateModeDefaultAzureCredentials(KustoOptions options)
+    {
+        if (options.ClusterUri is null)
+        {
+            return Fail(
+                $"The cluster URI cannot be null when using `{nameof(KustoClientCreationMode.DefaultAzureCredentials)}` mode."
+            );
+        }
+
+        if (!options.ClusterUri.IsAbsoluteUri)
+        {
+            return Fail(
+                $"The cluster URI must be an absolute URI when using `{nameof(KustoClientCreationMode.DefaultAzureCredentials)}` mode."
+            );
+        }
+
+        return Success;
+    }
+
+    private static ValidateOptionsResult ValidateModeConnectionString(KustoOptions options)
+    {
+        if (string.IsNullOrWhiteSpace(options.ConnectionString))
+        {
+            return Fail(
+                $"The connection string cannot be null or whitespace when using `{nameof(KustoClientCreationMode.ConnectionString)}` mode."
+            );
+        }
+
+        return Success;
+    }
+
+    private ValidateOptionsResult ValidateModeServiceProvider()
+    {
+        if (_serviceProvider.GetService<ICslQueryProvider>() is null)
+        {
+            return Fail(
+                $"No service of type `{nameof(ICslQueryProvider)}` registered. Please register a Kusto client."
+            );
+        }
+
+        return Success;
+    }
+}