Replace Nest to Elastic.Clients.Elasticsearch

src/HealthChecks.Elasticsearch/ElasticsearchHealthCheck.cs

@@ -1,13 +1,13 @@
 using System.Collections.Concurrent;
-using Elasticsearch.Net;
+using Elastic.Clients.Elasticsearch;
+using Elastic.Transport;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
-using Nest;
 
 namespace HealthChecks.Elasticsearch;
 
 public class ElasticsearchHealthCheck : IHealthCheck
 {
-    private static readonly ConcurrentDictionary<string, ElasticClient> _connections = new();
+    private static readonly ConcurrentDictionary<string, ElasticsearchClient> _connections = new();
 
     private readonly ElasticsearchOptions _options;
 
@@ -21,9 +21,9 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
     {
         try
         {
-            if (!_connections.TryGetValue(_options.Uri, out var lowLevelClient))
+            if (!_connections.TryGetValue(_options.Uri, out var elasticsearchClient))
             {
-                var settings = new ConnectionSettings(new Uri(_options.Uri));
+                var settings = new ElasticsearchClientSettings(new Uri(_options.Uri));
 
                 if (_options.RequestTimeout.HasValue)
                 {
@@ -32,49 +32,65 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
 
                 if (_options.AuthenticateWithBasicCredentials)
                 {
-                    settings = settings.BasicAuthentication(_options.UserName, _options.Password);
+                    if (_options.UserName is null)
+                    {
+                        throw new ArgumentNullException(nameof(_options.UserName));
+                    }
+                    if (_options.Password is null)
+                    {
+                        throw new ArgumentNullException(nameof(_options.Password));
+                    }
+                    settings = settings.Authentication(new BasicAuthentication(_options.UserName, _options.Password));
                 }
                 else if (_options.AuthenticateWithCertificate)
                 {
+                    if (_options.Certificate is null)
+                    {
+                        throw new ArgumentNullException(nameof(_options.Certificate));
+                    }
                     settings = settings.ClientCertificate(_options.Certificate);
                 }
                 else if (_options.AuthenticateWithApiKey)
                 {
-                    settings = settings.ApiKeyAuthentication(_options.ApiKeyAuthenticationCredentials);
+                    if (_options.ApiKey is null)
+                    {
+                        throw new ArgumentNullException(nameof(_options.ApiKey));
+                    }
+                    settings.Authentication(new ApiKey(_options.ApiKey));
                 }
 
                 if (_options.CertificateValidationCallback != null)
                 {
                     settings = settings.ServerCertificateValidationCallback(_options.CertificateValidationCallback);
                 }
 
-                lowLevelClient = new ElasticClient(settings);
+                elasticsearchClient = new ElasticsearchClient(settings);
 
-                if (!_connections.TryAdd(_options.Uri, lowLevelClient))
+                if (!_connections.TryAdd(_options.Uri, elasticsearchClient))
                 {
-                    lowLevelClient = _connections[_options.Uri];
+                    elasticsearchClient = _connections[_options.Uri];
                 }
             }
 
             if (_options.UseClusterHealthApi)
             {
-                var healthResponse = await lowLevelClient.Cluster.HealthAsync(ct: cancellationToken).ConfigureAwait(false);
+                var healthResponse = await elasticsearchClient.Cluster.HealthAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
 
-                if (healthResponse.ApiCall.HttpStatusCode != 200)
+                if (healthResponse.ApiCallDetails.HttpStatusCode != 200)
                 {
                     return new HealthCheckResult(context.Registration.FailureStatus);
                 }
 
                 return healthResponse.Status switch
                 {
-                    Health.Green => HealthCheckResult.Healthy(),
-                    Health.Yellow => HealthCheckResult.Degraded(),
+                    Elastic.Clients.Elasticsearch.HealthStatus.Green => HealthCheckResult.Healthy(),
+                    Elastic.Clients.Elasticsearch.HealthStatus.Yellow => HealthCheckResult.Degraded(),
                     _ => new HealthCheckResult(context.Registration.FailureStatus)
                 };
             }
 
-            var pingResult = await lowLevelClient.PingAsync(ct: cancellationToken).ConfigureAwait(false);
-            bool isSuccess = pingResult.ApiCall.HttpStatusCode == 200;
+            var pingResult = await elasticsearchClient.PingAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
+            bool isSuccess = pingResult.ApiCallDetails.HttpStatusCode == 200;
 
             return isSuccess
                 ? HealthCheckResult.Healthy()

src/HealthChecks.Elasticsearch/ElasticsearchOptions.cs

@@ -1,6 +1,5 @@
 using System.Net.Security;
 using System.Security.Cryptography.X509Certificates;
-using Elasticsearch.Net;
 
 namespace HealthChecks.Elasticsearch;
 
@@ -17,8 +16,6 @@ public class ElasticsearchOptions
 
     public X509Certificate? Certificate { get; private set; }
 
-    public ApiKeyAuthenticationCredentials? ApiKeyAuthenticationCredentials { get; private set; }
-
     public bool AuthenticateWithBasicCredentials { get; private set; }
 
     public bool AuthenticateWithCertificate { get; private set; }
@@ -27,6 +24,8 @@ public class ElasticsearchOptions
 
     public bool UseClusterHealthApi { get; set; }
 
+    public string? ApiKey { get; private set; }
+
     public Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool>? CertificateValidationCallback { get; private set; }
 
     public TimeSpan? RequestTimeout { get; set; }
@@ -55,9 +54,9 @@ public ElasticsearchOptions UseCertificate(X509Certificate certificate)
         return this;
     }
 
-    public ElasticsearchOptions UseApiKey(ApiKeyAuthenticationCredentials apiKey)
+    public ElasticsearchOptions UseApiKey(string apiKey)
     {
-        ApiKeyAuthenticationCredentials = Guard.ThrowIfNull(apiKey);
+        ApiKey = Guard.ThrowIfNull(apiKey);
 
         UserName = string.Empty;
         Password = string.Empty;

src/HealthChecks.Elasticsearch/HealthChecks.Elasticsearch.csproj

@@ -8,8 +8,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="NEST" Version="7.17.5" />
-    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="8.0.0" />
+    <PackageReference Include="Elastic.Clients.Elasticsearch" Version="8.14.3" />
+    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="8.0.6" />
+    <!--<PackageReference Include="NEST" Version="7.17.5" />-->
+
   </ItemGroup>
 
 </Project>

test/HealthChecks.Elasticsearch.Tests/Functional/ElasticsearchAuthenticationTests.cs

@@ -1,5 +1,4 @@
 using System.Net;
-using Elasticsearch.Net;
 using HealthChecks.Elasticsearch.Tests.Fixtures;
 
 namespace HealthChecks.Elasticsearch.Tests.Functional;
@@ -25,7 +24,7 @@ public async Task be_healthy_if_elasticsearch_is_using_valid_api_key()
                     .AddElasticsearch(options =>
                     {
                         options.UseServer(connectionString);
-                        options.UseApiKey(new ApiKeyAuthenticationCredentials(_fixture.ApiKey));
+                        options.UseApiKey(_fixture.ApiKey!);
                         options.UseCertificateValidationCallback(delegate
                         {
                             return true;