Add CouchDb health check implementation with tests

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

Author: Copilot

Directory.Packages.props

@@ -63,6 +63,7 @@
     <PackageVersion Include="Microsoft.Extensions.Http" Version="9.0.10" />
     <PackageVersion Include="Microsoft.Testing.Extensions.CodeCoverage" Version="18.1.0" />
     <PackageVersion Include="MongoDB.Driver" Version="3.5.0" />
+    <PackageVersion Include="MyCouch" Version="7.6.0" />
     <PackageVersion Include="MySql.Data" Version="9.5.0" />
     <PackageVersion Include="MySqlConnector" Version="2.4.0" />
     <PackageVersion Include="Net.IBM.Data.Db2" Version="9.0.0.400" />
@@ -92,6 +93,7 @@
     <PackageVersion Include="Testcontainers.Azurite" Version="$(VersionTestContainers)" />
     <PackageVersion Include="Testcontainers.ClickHouse" Version="$(VersionTestContainers)" />
     <PackageVersion Include="Testcontainers.Consul" Version="$(VersionTestContainers)" />
+    <PackageVersion Include="Testcontainers.CouchDb" Version="$(VersionTestContainers)" />
     <PackageVersion Include="Testcontainers.Db2" Version="$(VersionTestContainers)" />
     <PackageVersion Include="Testcontainers.Elasticsearch" Version="$(VersionTestContainers)" />
     <PackageVersion Include="Testcontainers.EventHubs" Version="$(VersionTestContainers)" />

HealthChecks.slnx

@@ -43,6 +43,7 @@
     <Project Path="src/NetEvolve.HealthChecks.Azure/NetEvolve.HealthChecks.Azure.csproj" />
     <Project Path="src/NetEvolve.HealthChecks.ClickHouse/NetEvolve.HealthChecks.ClickHouse.csproj" />
     <Project Path="src/NetEvolve.HealthChecks.Consul/NetEvolve.HealthChecks.Consul.csproj" />
+    <Project Path="src/NetEvolve.HealthChecks.CouchDb/NetEvolve.HealthChecks.CouchDb.csproj" />
     <Project Path="src/NetEvolve.HealthChecks.Dapr/NetEvolve.HealthChecks.Dapr.csproj" />
     <Project Path="src/NetEvolve.HealthChecks.DB2/NetEvolve.HealthChecks.DB2.csproj" />
     <Project Path="src/NetEvolve.HealthChecks.DuckDB/NetEvolve.HealthChecks.DuckDB.csproj" />

src/NetEvolve.HealthChecks.CouchDb/CouchDbConfigure.cs

@@ -0,0 +1,54 @@
+namespace NetEvolve.HealthChecks.CouchDb;
+
+using System.Threading;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using static Microsoft.Extensions.Options.ValidateOptionsResult;
+
+internal sealed class CouchDbConfigure : IConfigureNamedOptions<CouchDbOptions>, IValidateOptions<CouchDbOptions>
+{
+    private readonly IConfiguration _configuration;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CouchDbConfigure"/> class.
+    /// </summary>
+    /// <param name="configuration">The <see cref="IConfiguration"/> instance used to bind configuration values.</param>
+    public CouchDbConfigure(IConfiguration configuration) => _configuration = configuration;
+
+    /// <inheritdoc />
+    public void Configure(string? name, CouchDbOptions options)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(name);
+        _configuration.Bind($"HealthChecks:CouchDb:{name}", options);
+    }
+
+    /// <inheritdoc />
+    public void Configure(CouchDbOptions options) => Configure(Options.DefaultName, options);
+
+    /// <inheritdoc />
+    public ValidateOptionsResult Validate(string? name, CouchDbOptions 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 (string.IsNullOrWhiteSpace(options.ConnectionString))
+        {
+            return Fail("The connection string cannot be null or whitespace.");
+        }
+
+        if (options.Timeout < Timeout.Infinite)
+        {
+            return Fail("The timeout value must be a positive number in milliseconds or -1 for an infinite timeout.");
+        }
+
+        return Success;
+    }
+}

src/NetEvolve.HealthChecks.CouchDb/CouchDbHealthCheck.cs

@@ -0,0 +1,40 @@
+namespace NetEvolve.HealthChecks.CouchDb;
+
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using MyCouch;
+using SourceGenerator.Attributes;
+
+[ConfigurableHealthCheck(typeof(CouchDbOptions))]
+internal sealed partial class CouchDbHealthCheck
+{
+    private static async ValueTask<HealthCheckResult> ExecuteHealthCheckAsync(
+        string name,
+#pragma warning disable S1172 // Unused method parameters should be removed
+        HealthStatus failureStatus,
+#pragma warning restore S1172 // Unused method parameters should be removed
+        CouchDbOptions options,
+        CancellationToken cancellationToken
+    )
+    {
+        var dbUri = new Uri(options.ConnectionString!);
+        var connectionInfo = new DbConnectionInfo(
+            dbUri.GetLeftPart(UriPartial.Authority),
+            dbUri.AbsolutePath.Trim('/')
+        );
+        using var client = new MyCouchClient(connectionInfo);
+
+        var sw = Stopwatch.StartNew();
+        await options.CommandAsync.Invoke(client, cancellationToken).ConfigureAwait(false);
+        sw.Stop();
+
+        var isTimelyResponse = options.Timeout >= sw.Elapsed.TotalMilliseconds;
+
+        return HealthCheckState(isTimelyResponse, name);
+    }
+
+    internal static async Task DefaultCommandAsync(MyCouchClient client, CancellationToken cancellationToken) =>
+        _ = await client.Database.HeadAsync(cancellationToken).ConfigureAwait(false);
+}

src/NetEvolve.HealthChecks.CouchDb/CouchDbOptions.cs

@@ -0,0 +1,26 @@
+namespace NetEvolve.HealthChecks.CouchDb;
+
+using MyCouch;
+
+/// <summary>
+/// Options for <see cref="CouchDbHealthCheck"/>
+/// </summary>
+public sealed record CouchDbOptions
+{
+    /// <summary>
+    /// Gets or sets the connection string for the CouchDb server.
+    /// </summary>
+    public string? ConnectionString { get; set; }
+
+    /// <summary>
+    /// The timeout to use when connecting and executing tasks against database.
+    /// </summary>
+    public int Timeout { get; set; } = 100;
+
+    /// <summary>
+    /// The command to execute against the database.
+    /// </summary>
+    /// <remarks>For internal use only.</remarks>
+    public Func<MyCouchClient, CancellationToken, Task> CommandAsync { get; internal set; } =
+        CouchDbHealthCheck.DefaultCommandAsync;
+}

src/NetEvolve.HealthChecks.CouchDb/DependencyInjectionExtensions.cs

@@ -0,0 +1,64 @@
+namespace NetEvolve.HealthChecks.CouchDb;
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using SourceGenerator.Attributes;
+
+/// <summary>
+/// Extensions methods for <see cref="IHealthChecksBuilder"/> with custom Health Checks.
+/// </summary>
+[HealthCheckHelper]
+public static partial class DependencyInjectionExtensions
+{
+    private static readonly string[] _defaultTags = ["couchdb", "nosql"];
+
+    /// <summary>
+    /// Add a health check for the CouchDb database.
+    /// </summary>
+    /// <param name="builder">The <see cref="IHealthChecksBuilder"/>.</param>
+    /// <param name="name">The name of the <see cref="CouchDbHealthCheck"/>.</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 AddCouchDb(
+        [NotNull] this IHealthChecksBuilder builder,
+        [NotNull] string name,
+        Action<CouchDbOptions>? options = null,
+        params string[] tags
+    )
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentException.ThrowIfNullOrEmpty(name);
+        ArgumentNullException.ThrowIfNull(tags);
+
+        if (!builder.IsServiceTypeRegistered<CouchDbCheckMarker>())
+        {
+            _ = builder
+                .Services.AddSingleton<CouchDbCheckMarker>()
+                .AddSingleton<CouchDbHealthCheck>()
+                .ConfigureOptions<CouchDbConfigure>();
+        }
+
+        builder.ThrowIfNameIsAlreadyUsed<CouchDbHealthCheck>(name);
+
+        if (options is not null)
+        {
+            _ = builder.Services.Configure(name, options);
+        }
+
+        return builder.AddCheck<CouchDbHealthCheck>(
+            name,
+            HealthStatus.Unhealthy,
+            _defaultTags.Union(tags, StringComparer.OrdinalIgnoreCase)
+        );
+    }
+
+    private sealed partial class CouchDbCheckMarker;
+}

src/NetEvolve.HealthChecks.CouchDb/NetEvolve.HealthChecks.CouchDb.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>$(_ProjectTargetFrameworks)</TargetFrameworks>
+    <Description>Contains HealthChecks for CouchDb, based on the nuget package `MyCouch`.</Description>
+    <PackageTags>$(PackageTags);couchdb;nosql</PackageTags>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="MyCouch" />
+    <PackageReference Include="NetEvolve.Extensions.Tasks" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\SourceGenerator.Attributes\SourceGenerator.Attributes.csproj" PrivateAssets="all" />
+    <ProjectReference
+      Include="..\SourceGenerator.HealthChecks\SourceGenerator.HealthChecks.csproj"
+      ReferenceOutputAssembly="false"
+      OutputItemType="Analyzer"
+    />
+  </ItemGroup>
+</Project>

src/NetEvolve.HealthChecks.CouchDb/README.md

@@ -0,0 +1,78 @@
+# NetEvolve.HealthChecks.CouchDb
+
+[![NuGet](https://img.shields.io/nuget/v/NetEvolve.HealthChecks.CouchDb?logo=nuget)](https://www.nuget.org/packages/NetEvolve.HealthChecks.CouchDb/)
+[![NuGet](https://img.shields.io/nuget/dt/NetEvolve.HealthChecks.CouchDb?logo=nuget)](https://www.nuget.org/packages/NetEvolve.HealthChecks.CouchDb/)
+
+This package provides a health check for CouchDb databases, based on the [MyCouch](https://www.nuget.org/packages/MyCouch/) package. The main purpose is to check if the database is available and if the database is online.
+
+:bulb: This package is available for .NET 8.0 and later.
+
+## Installation
+To use this package, you need to add the package to your project. You can do this by using the NuGet package manager or by using the dotnet CLI.
+```powershell
+dotnet add package NetEvolve.HealthChecks.CouchDb
+```
+
+## Health Check - CouchDb Liveness
+The health check is a liveness check. It checks if the CouchDb Server is available and if the database is online.
+If the query needs longer than the configured timeout, the health check will return `Degraded`.
+If the query fails, for whatever reason, the health check will return `Unhealthy`.
+
+### Usage
+After adding the package, you need to import the namespace and add the health check to the health check builder.
+```csharp
+using NetEvolve.HealthChecks.CouchDb;
+```
+Therefore, you can use two different approaches. In both approaches you have to provide a name for the health check.
+
+### Parameters
+- `name`: The name of the health check. The name is used to identify the configuration object. It is required and must be unique within the application.
+- `options`: The configuration options for the health check. If you don't provide any options, the health check will use the configuration based approach.
+- `tags`: The tags for the health check. The tags `couchdb` and `nosql` are always used as default and combined with the user input. You can provide additional tags to group or filter the health checks.
+
+### Variant 1: Configuration based
+The first one is to use the configuration based approach. This approach is recommended if you have multiple CouchDb instances to check.
+```csharp
+var builder = services.AddHealthChecks();
+
+builder.AddCouchDb("<name>");
+```
+
+The configuration looks like this:
+```json
+{
+  ..., // other configuration
+  "HealthChecks": {
+    "CouchDb": {
+      "<name>": {
+        "ConnectionString": "<connection string>",
+        "Timeout": "<timeout>" // optional, default is 100 milliseconds
+      }
+    }
+  }
+}
+```
+
+### Variant 2: Builder based
+The second approach is to use the builder based approach. This approach is recommended if you only have one NoSQL Server instance to check or dynamic programmatic values.
+```csharp
+var builder = services.AddHealthChecks();
+
+builder.AddCouchDb("<name>", options =>
+{
+    options.ConnectionString = "<connection string>";
+    options.Timeout = "<timeout>"; // optional, default is 100 milliseconds
+});
+```
+
+### :bulb: You can always provide tags to all health checks, for grouping or filtering.
+
+```csharp
+var builder = services.AddHealthChecks();
+
+builder.AddCouchDb("<name>", options => ..., "CouchDb", "database");
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](https://raw.githubusercontent.com/dailydevops/healthchecks/refs/heads/main/LICENSE) file for details.

tests/NetEvolve.HealthChecks.Tests.Integration/CouchDb/CouchDbDatabase.cs

@@ -0,0 +1,16 @@
+namespace NetEvolve.HealthChecks.Tests.Integration.CouchDb;
+
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging.Abstractions;
+using Testcontainers.CouchDb;
+
+public sealed class CouchDbDatabase : IAsyncInitializer, IAsyncDisposable
+{
+    private readonly CouchDbContainer _database = new CouchDbBuilder().WithLogger(NullLogger.Instance).Build();
+
+    public string ConnectionString => _database.GetConnectionString();
+
+    public async ValueTask DisposeAsync() => await _database.DisposeAsync().ConfigureAwait(false);
+
+    public async Task InitializeAsync() => await _database.StartAsync().ConfigureAwait(false);
+}