feat: implement local service health check

Consul.Test/AgentTest.cs

@@ -569,6 +569,150 @@ public async Task Agent_MonitorJSON()
             }
         }
 
+        [Theory]
+        [InlineData("passing")]
+        [InlineData("warning")]
+        [InlineData("critical")]
+        public async Task Agent_GetLocalServiceHealth(string statusString)
+        {
+            var healthStatus = HealthStatus.Parse(statusString);
+            var svcID = KVTest.GenerateTestKeyName();
+            var registration = new AgentServiceRegistration
+            {
+                Name = svcID,
+                Tags = new[] { "bar", "baz" },
+                Port = 8000,
+                Checks = new[]
+                {
+                    new AgentServiceCheck
+                    {
+                        TTL = TimeSpan.FromSeconds(15),
+                        Status = HealthStatus.Passing,
+                    },
+                    new AgentServiceCheck
+                    {
+                        TTL = TimeSpan.FromSeconds(15),
+                        Status = healthStatus,
+                    }
+                }
+            };
+
+            await _client.Agent.ServiceRegister(registration);
+
+            var status = await _client.Agent.GetLocalServiceHealth(svcID);
+
+            Assert.Equal(healthStatus, status.Response[0].AggregatedStatus);
+        }
+
+        [Theory]
+        [InlineData("passing")]
+        [InlineData("warning")]
+        [InlineData("critical")]
+        public async Task Agent_GetLocalServiceHealthByID(string statusString)
+        {
+            var healthStatus = HealthStatus.Parse(statusString);
+            var svcID = KVTest.GenerateTestKeyName();
+            var registration = new AgentServiceRegistration
+            {
+                ID = svcID,
+                Name = svcID,
+                Tags = new[] { "bar", "baz" },
+                Port = 8000,
+                Checks = new[]
+                {
+                    new AgentServiceCheck
+                    {
+                        TTL = TimeSpan.FromSeconds(15),
+                        Status = HealthStatus.Passing,
+                    },
+                    new AgentServiceCheck
+                    {
+                        TTL = TimeSpan.FromSeconds(15),
+                        Status = healthStatus,
+                    }
+                }
+            };
+
+            await _client.Agent.ServiceRegister(registration);
+
+            var status = await _client.Agent.GetLocalServiceHealthByID(svcID);
+
+            Assert.Equal(healthStatus, status.Response[0].AggregatedStatus);
+        }
+
+        [Theory]
+        [InlineData("passing")]
+        [InlineData("warning")]
+        [InlineData("critical")]
+        public async Task Agent_GetWorstLocalServiceHealth(string statusString)
+        {
+            var healthStatus = HealthStatus.Parse(statusString);
+            var svcID = KVTest.GenerateTestKeyName();
+
+            var registration = new AgentServiceRegistration
+            {
+                Name = svcID,
+                Tags = new[] { "bar", "baz" },
+                Port = 8000,
+                Checks = new[]
+                {
+                    new AgentServiceCheck
+                    {
+                        TTL = TimeSpan.FromSeconds(15),
+                        Status = HealthStatus.Passing,
+                    },
+                    new AgentServiceCheck
+                    {
+                        TTL = TimeSpan.FromSeconds(15),
+                        Status = healthStatus,
+                    }
+                }
+            };
+
+            await _client.Agent.ServiceRegister(registration);
+
+            var status = await _client.Agent.GetWorstLocalServiceHealth(svcID);
+
+            Assert.Equal(healthStatus.Status, status.Response);
+        }
+
+        [Theory]
+        [InlineData("passing")]
+        [InlineData("warning")]
+        [InlineData("critical")]
+        public async Task Agent_GetWorstLocalServiceHealthByID(string statusString)
+        {
+            var healthStatus = HealthStatus.Parse(statusString);
+            var svcID = KVTest.GenerateTestKeyName();
+
+            var registration = new AgentServiceRegistration
+            {
+                ID = svcID,
+                Name = svcID,
+                Tags = new[] { "bar", "baz" },
+                Port = 8000,
+                Checks = new[]
+                {
+                    new AgentServiceCheck
+                    {
+                        TTL = TimeSpan.FromSeconds(15),
+                        Status = HealthStatus.Passing,
+                    },
+                    new AgentServiceCheck
+                    {
+                        TTL = TimeSpan.FromSeconds(15),
+                        Status = healthStatus,
+                    }
+                }
+            };
+
+            await _client.Agent.ServiceRegister(registration);
+
+            var status = await _client.Agent.GetWorstLocalServiceHealthByID(svcID);
+
+            Assert.Equal(healthStatus.Status, status.Response);
+        }
+
         [Fact]
         public async Task Agent_FilterServices()
         {

Consul/Agent.cs

@@ -404,6 +404,20 @@ public class AgentServiceCheck
         public TimeSpan? DeregisterCriticalServiceAfter { get; set; }
     }
 
+
+    /// <summary>
+    /// LocalServiceHealth represents the health of a service and its associated checks as returned by the Agent API
+    /// </summary>
+    public class LocalServiceHealth
+    {
+        [JsonConverter(typeof(HealthStatusConverter))]
+        public HealthStatus AggregatedStatus { get; set; }
+
+        public AgentService Service { get; set; }
+
+        public AgentCheck[] Checks { get; set; }
+    }
+
     /// <summary>
     /// Log Level Enum
     /// </summary>
@@ -668,7 +682,6 @@ public Task<WriteResult> ForceLeave(string node, CancellationToken ct = default)
             return _client.PutNothing(string.Format("/v1/agent/force-leave/{0}", node)).Execute(ct);
         }
 
-
         /// <summary>
         /// Leave is used to have the agent gracefully leave the cluster and shutdown
         /// </summary>
@@ -764,6 +777,91 @@ public async Task<LogStream> MonitorJSON(LogLevel level = default, CancellationT
             return new LogStream(res.Response);
         }
 
+        /// <summary>
+        /// GetLocalServiceHealth returns the health info of a service registered on the local agent
+        /// </summary>
+        /// <param name="serviceName">Name of service</param>
+        /// <returns>An array containing the details of each passing, warning, or critical service</returns>
+        public async Task<QueryResult<LocalServiceHealth[]>> GetLocalServiceHealth(string serviceName, QueryOptions q, CancellationToken ct = default)
+        {
+            return await _client.Get<LocalServiceHealth[]>($"v1/agent/health/service/name/{serviceName}", q).Execute(ct).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// GetLocalServiceHealth returns the health info of a service registered on the local agent
+        /// </summary>
+        /// <param name="serviceName">Name of service</param>
+        /// <returns>An array containing the details of each passing, warning, or critical service</returns>
+        public async Task<QueryResult<LocalServiceHealth[]>> GetLocalServiceHealth(string serviceName, CancellationToken ct = default)
+        {
+            return await GetLocalServiceHealth(serviceName, QueryOptions.Default, ct).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// GetWorstLocalServiceHealth returns the worst aggregated status of a service registered on the local agent
+        /// </summary>
+        /// <param name="serviceName">Name of service</param>
+        /// <returns>passing, warning, or critical</returns>
+        public async Task<QueryResult<string>> GetWorstLocalServiceHealth(string serviceName, QueryOptions q, CancellationToken ct = default)
+        {
+            var req = _client.Get($"v1/agent/health/service/name/{serviceName}", q);
+            req.Params["format"] = "text";
+            return await req.Execute(ct).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// GetWorstLocalServiceHealth returns the worst aggregated status of a service registered on the local agent
+        /// </summary>
+        /// <param name="serviceName">Name of service</param>
+        /// <returns>passing, warning, or critical</returns>
+        public async Task<QueryResult<string>> GetWorstLocalServiceHealth(string serviceName, CancellationToken ct = default)
+        {
+            return await GetWorstLocalServiceHealth(serviceName, QueryOptions.Default, ct).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// GetLocalServiceHealthByID returns the health info of a service registered on the local agent by ID
+        /// </summary>
+        /// <param name="serviceID">ID of the service</param>
+        /// <returns>An array containing the details of each passing, warning, or critical service</returns>
+        public async Task<QueryResult<LocalServiceHealth[]>> GetLocalServiceHealthByID(string serviceID, QueryOptions q, CancellationToken ct = default)
+        {
+            return await _client.Get<LocalServiceHealth[]>($"v1/agent/health/service/id/{serviceID}", q).Execute(ct).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// GetLocalServiceHealthByID returns the health info of a service registered on the local agent by ID
+        /// </summary>
+        /// <param name="serviceID">ID of the service</param>
+        /// <returns>An array containing the details of each passing, warning, or critical service</returns>
+        public async Task<QueryResult<LocalServiceHealth[]>> GetLocalServiceHealthByID(string serviceID, CancellationToken ct = default)
+        {
+            return await GetLocalServiceHealth(serviceID, QueryOptions.Default, ct).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// GetWorstLocalServiceHealthByID returns the worst aggregated status of a service registered on the local agent by ID
+        /// </summary>
+        /// <param name="serviceID">ID of the service</param>
+        /// <returns>passing, warning, or critical</returns>
+        public async Task<QueryResult<string>> GetWorstLocalServiceHealthByID(string serviceID, QueryOptions q, CancellationToken ct = default)
+        {
+            var req = _client.Get($"v1/agent/health/service/id/{serviceID}", q);
+            req.Params["format"] = "text";
+
+            return await req.Execute(ct).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// GetWorstLocalServiceHealthByID returns the worst aggregated status of a service registered on the local agent by ID
+        /// </summary>
+        /// <param name="serviceID">ID of the service</param>
+        /// <returns>passing, warning, or critical</returns>
+        public async Task<QueryResult<string>> GetWorstLocalServiceHealthByID(string serviceID, CancellationToken ct = default)
+        {
+            return await GetWorstLocalServiceHealthByID(serviceID, QueryOptions.Default, ct).ConfigureAwait(false);
+        }
+
         /// <summary>
         /// Log streamer
         /// </summary>

Consul/Client_GetRequests.cs

@@ -79,8 +79,13 @@ public async Task<QueryResult<TOut>> Execute(CancellationToken ct)
             result.StatusCode = response.StatusCode;
             ResponseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
 
-            if (response.StatusCode != HttpStatusCode.NotFound && !response.IsSuccessStatusCode)
+            var isSpecialStatusCode = response.StatusCode == HttpStatusCode.ServiceUnavailable || (int)response.StatusCode == 429;
+
+            if (!response.IsSuccessStatusCode && !isSpecialStatusCode && (
+                (response.StatusCode != HttpStatusCode.NotFound && typeof(TOut) != typeof(TxnResponse)) ||
+                (response.StatusCode != HttpStatusCode.Conflict && typeof(TOut) == typeof(TxnResponse))))
             {
+
                 if (ResponseStream == null)
                 {
                     throw new ConsulRequestException(string.Format("Unexpected response, status code {0}",
@@ -93,7 +98,7 @@ public async Task<QueryResult<TOut>> Execute(CancellationToken ct)
                 }
             }
 
-            if (response.IsSuccessStatusCode)
+            if (response.IsSuccessStatusCode || isSpecialStatusCode)
             {
                 result.Response = Deserialize<TOut>(ResponseStream);
             }
@@ -320,7 +325,9 @@ public async Task<QueryResult<string>> Execute(CancellationToken ct)
             result.StatusCode = response.StatusCode;
             ResponseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
 
-            if (response.StatusCode != HttpStatusCode.NotFound && !response.IsSuccessStatusCode)
+            var isSpecialStatusCode = response.StatusCode == HttpStatusCode.ServiceUnavailable || (int)response.StatusCode == 429;
+
+            if (!isSpecialStatusCode && response.StatusCode != HttpStatusCode.NotFound && !response.IsSuccessStatusCode)
             {
                 if (ResponseStream == null)
                 {
@@ -334,7 +341,7 @@ public async Task<QueryResult<string>> Execute(CancellationToken ct)
                 }
             }
 
-            if (response.IsSuccessStatusCode)
+            if (response.IsSuccessStatusCode || isSpecialStatusCode)
             {
                 using (var reader = new StreamReader(ResponseStream))
                 {

Consul/Health.cs

@@ -45,6 +45,21 @@ public class HealthStatus : IEquatable<HealthStatus>
 
         public static HealthStatus Any { get; } = new HealthStatus() { Status = "any" };
 
+        public static HealthStatus Parse(string status)
+        {
+            switch (status)
+            {
+                case "passing":
+                    return Passing;
+                case "warning":
+                    return Warning;
+                case "critical":
+                    return Critical;
+                default:
+                    throw new ArgumentException("Invalid Check status value during deserialization");
+            }
+        }
+
         public bool Equals(HealthStatus other)
         {
             return other != null && ReferenceEquals(this, other);

Consul/Interfaces/IAgentEndpoint.cs

@@ -56,6 +56,14 @@ public interface IAgentEndpoint
         Task WarnTTL(string checkID, string note, CancellationToken ct = default);
         Task<Agent.LogStream> Monitor(LogLevel level = default, CancellationToken ct = default);
         Task<Agent.LogStream> MonitorJSON(LogLevel level = default, CancellationToken ct = default);
+        Task<QueryResult<LocalServiceHealth[]>> GetLocalServiceHealth(string serviceName, QueryOptions q, CancellationToken ct = default);
+        Task<QueryResult<LocalServiceHealth[]>> GetLocalServiceHealth(string serviceName, CancellationToken ct = default);
+        Task<QueryResult<string>> GetWorstLocalServiceHealth(string serviceName, QueryOptions q, CancellationToken ct = default);
+        Task<QueryResult<string>> GetWorstLocalServiceHealth(string serviceName, CancellationToken ct = default);
+        Task<QueryResult<LocalServiceHealth[]>> GetLocalServiceHealthByID(string serviceID, QueryOptions q, CancellationToken ct = default);
+        Task<QueryResult<LocalServiceHealth[]>> GetLocalServiceHealthByID(string serviceID, CancellationToken ct = default);
+        Task<QueryResult<string>> GetWorstLocalServiceHealthByID(string serviceID, QueryOptions q, CancellationToken ct = default);
+        Task<QueryResult<string>> GetWorstLocalServiceHealthByID(string serviceID, CancellationToken ct = default);
 
         Task<WriteResult> Leave(string node, CancellationToken ct = default);
         Task<WriteResult> Reload(string node, CancellationToken ct = default);