public Task <HealthCheckResult> CheckHealthAsync(
HealthCheckContext context,
CancellationToken cancellationToken = default)
{
var options = _options.Get(context.Registration.Name);
// Include GC information in the reported diagnostics.
var allocated = GC.GetTotalMemory(forceFullCollection: false);
var data = new Dictionary <string, object>()
{
{ "AllocatedBytes", allocated },
{ "Gen0Collections", GC.CollectionCount(0) },
{ "Gen1Collections", GC.CollectionCount(1) },
{ "Gen2Collections", GC.CollectionCount(2) },
};
var status = (allocated < options.Threshold) ? HealthStatus.Healthy : context.Registration.FailureStatus;
return(Task.FromResult(new HealthCheckResult(
status,
description: "Reports degraded status if allocated bytes " + $">= {options.Threshold} bytes.",
exception: null,
data: data)));
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default(CancellationToken))
{
using (var connection = CreateConnection(ConnectionString))
{
try
{
await connection.OpenAsync(cancellationToken);
if (TestQuery != null)
{
var command = connection.CreateCommand();
command.CommandText = TestQuery;
await command.ExecuteNonQueryAsync(cancellationToken);
}
}
catch (DbException ex)
{
return(new HealthCheckResult(status: context.Registration.FailureStatus, exception: ex));
}
}
return(HealthCheckResult.Healthy());
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var path = new[] { "healthcheck", "healthcheck_file.bin" };
await _storage.Save(new byte[] { 1, 2, 3 }, path);
var bytes = await _storage.Load(path);
await _storage.Delete(path);
if (bytes != null && bytes.Length != 3 && bytes[0] != 1 && bytes[1] != 2 && bytes[2] != 3)
{
return(new HealthCheckResult(HealthStatus.Unhealthy, "Content does not match"));
}
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(HealthStatus.Unhealthy, null, ex));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
var fluentdHostAddress = string.Empty;
try
{
fluentdHostAddress = Environment.GetEnvironmentVariable("FLUENTD_HOST") ?? throw new ArgumentNullException("Missing 'FLUENTD_HOST' environment variable .");
var request = new HttpRequestMessage(HttpMethod.Get, fluentdHostAddress);
var client = _clientFactory.CreateClient();
client.Timeout = TimeSpan.FromSeconds(5);
var response = await client.SendAsync(request, cancellationToken);
response.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
return(HealthCheckResult.Unhealthy($"HealthCheck request to Fluentd endpoint {fluentdHostAddress} failed with error message [{ex.Message}]"));
}
return(HealthCheckResult.Healthy());
}
public async Task Then_If_The_Status_Is_Healthy_Then_A_Healthy_Response_Is_Returned(
[Frozen] Mock <IAzureQueueService> azureQueueService,
HealthCheckContext healthCheckContext,
QueueHealthCheck handler
)
{
//Arrange
var expectedQueueName = "test.queue";
var queueMonitor = new QueueMonitor(expectedQueueName, false);
azureQueueService.Setup(x => x.GetQueuesToMonitor()).Returns(new List <QueueMonitor>
{
queueMonitor
});
azureQueueService.Setup(x => x.IsQueueHealthy(expectedQueueName)).ReturnsAsync(true);
//Act
var actual = await handler.CheckHealthAsync(healthCheckContext, CancellationToken.None);
//Assert
azureQueueService.Verify(x => x.IsQueueHealthy(expectedQueueName), Times.Once);
Assert.AreEqual(HealthStatus.Healthy, actual.Status);
Assert.IsFalse(actual.Data.ContainsKey("QueuesInError"));
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
using var ping = new Ping();
var reply = await ping.SendPingAsync(Host);
switch (reply.Status)
{
case IPStatus.Success:
var msg = $"ICMP to {Host} took {reply.RoundtripTime} ms.";
return((reply.RoundtripTime > HealthyRoundtripTime) ? HealthCheckResult.Degraded(msg) : HealthCheckResult.Healthy(msg));
default:
return(HealthCheckResult.Unhealthy($"ICMP to {Host} failed: {reply.Status}"));
}
}
catch (Exception ex)
{
var err = $"ICMP to {Host} failed: {ex.Message}";
return(HealthCheckResult.Unhealthy(err));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
var messageQueuesHealth = CheckAllMessageQueuesHealth();
await Task.WhenAll(messageQueuesHealth);
if (messageQueuesHealth.Result.Status == HealthStatus.Healthy)
{
logger.LogDebug(EventIds.AzureMessageQueueIsHealthy.ToEventId(), "Azure message queue is healthy");
return(HealthCheckResult.Healthy("Azure message queue is healthy"));
}
else
{
logger.LogError(EventIds.AzureMessageQueueIsUnhealthy.ToEventId(), messageQueuesHealth.Exception, "Azure message queue is unhealthy with error {Message}", messageQueuesHealth.Result.Exception.Message);
return(HealthCheckResult.Unhealthy("Azure message queue is unhealthy", messageQueuesHealth.Exception));
}
}
catch (Exception ex)
{
logger.LogError(EventIds.AzureMessageQueueIsUnhealthy.ToEventId(), ex, "Azure message queue is unhealthy with error {Message}", ex.Message);
return(HealthCheckResult.Unhealthy("Azure message queue is unhealthy", ex));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
HubConnection?connection = null;
try
{
connection = _hubConnectionBuilder();
await connection.StartAsync(cancellationToken);
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
finally
{
if (connection != null)
{
await connection.DisposeAsync();
}
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
var connectionKey = $"{_connectionString}_{_topicName}_{_subscriptionName}";
if (!_managementClientConnections.TryGetValue(connectionKey, out var managementClient))
{
managementClient = new ServiceBusAdministrationClient(_connectionString);
if (!_managementClientConnections.TryAdd(connectionKey, managementClient))
{
return(new HealthCheckResult(context.Registration.FailureStatus, description:
"New service bus administration client connection can't be added into dictionary."));
}
}
_ = await managementClient.GetSubscriptionRuntimePropertiesAsync(_topicName, _subscriptionName, cancellationToken);
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default(CancellationToken))
{
//using (var connection = new SqlConnection(ConnectionString))
//{
// try
// {
// await connection.OpenAsync(cancellationToken);
// if (TestQuery != null)
// {
// var command = connection.CreateCommand();
// command.CommandText = TestQuery;
// await command.ExecuteNonQueryAsync(cancellationToken);
// }
// }
// catch (DbException ex)
// {
// return new HealthCheckResult(status: context.Registration.FailureStatus, exception: ex);
// }
//}
return(HealthCheckResult.Healthy());
}
public async Task <HealthCheckResult> CheckHealthAsync(
HealthCheckContext context,
CancellationToken cancellationToken = default)
{
try
{
using var ping = new Ping();
var reply = await ping.SendPingAsync(Host);
switch (reply.Status)
{
case IPStatus.Success:
var msg = String.Format(
"IMCP to {0} took {1} ms.",
Host, reply.RoundtripTime);
return((reply.RoundtripTime > Timeout)
? HealthCheckResult.Degraded(msg)
: HealthCheckResult.Healthy(msg));
default:
var err = String.Format(
"IMCP to {0} failed: {1}",
Host,
reply.Status);
return(HealthCheckResult.Unhealthy(err));
}
}
catch (Exception ex)
{
var err = String.Format(
"IMCP to {0} failed: {1}",
Host,
ex.Message);
return(HealthCheckResult.Unhealthy(err));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default(CancellationToken))
{
return(await Task.Run(() =>
{
IDictionary <string, Object> data = new Dictionary <string, object>();
data.Add("type", "ProcessListHealthChecks");
UInt32 totalsize = 0;
Double TotalProcessorTime = 0;
int number = 0;
foreach (var aProc in Process.GetProcesses())
{
number++;
data.Add(aProc.ProcessName + "_Memory " + number.ToString(), aProc.WorkingSet64 / 1024);
try
{
data.Add(aProc.ProcessName + "_TotalProcessorTime " + number.ToString(), aProc.TotalProcessorTime.TotalSeconds);
TotalProcessorTime += aProc.TotalProcessorTime.TotalSeconds;
}
catch (Exception ex)
{
if (!string.IsNullOrWhiteSpace(ex.Message))
{
data.Add("error", ex.Message);
}
// data.Add(aProc.ProcessName + "_TotalProcessorTime " + number.ToString(), "Failed to load");
}
totalsize += Convert.ToUInt32(aProc.WorkingSet64 / 1024.0);
}
data.Add("Total Memory", totalsize);
data.Add("Total TotalProcessorTime", TotalProcessorTime);
ReadOnlyDictionary <string, Object> rodata = new ReadOnlyDictionary <string, object>(data);
string description = "ProcessList Total Memory Usage " + totalsize + " MB";
return HealthCheckResult.Healthy(description, rodata);
}));
}
public override async Task <HealthCheckResult> DoCheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
var url = httpContextAccessor.HttpContext.Request.Scheme + "://" + httpContextAccessor.HttpContext.Request.Host;
var content = await httpClient.GetStringAsync($"{url}/api/article", cancellationToken);
var articles = JsonConvert.DeserializeObject <IReadOnlyList <ArticleDto> >(content);
if (articles.Count == 0)
{
return(HealthCheckResult.Degraded("No article was returned from the web api"));
}
if (articles.Any(x => x.IsPublished() && string.IsNullOrEmpty(x.Content)))
{
return(HealthCheckResult.Degraded("At least one published article has no content"));
}
if (articles.Any(x => x.IsPublished() && string.IsNullOrEmpty(x.Title)))
{
return(HealthCheckResult.Degraded("At least one published article has no title"));
}
return(HealthCheckResult.Healthy("The web api returns articles"));
}
public async Task <HealthCheckResult> CheckHealthAsync(
HealthCheckContext context,
CancellationToken cancellationToken = new CancellationToken())
{
logger.LogInformation($"Executing health check for {nameof(SpeakerService)}.");
try
{
var response = await CheckService(cancellationToken);
logger.LogInformation($"Executed health check for {nameof(SpeakerService)}.");
if ((response.StatusCode == HttpStatusCode.Unauthorized ||
response.StatusCode == HttpStatusCode.Forbidden) &&
!"Site Disabled".Equals(response.ReasonPhrase, StringComparison.InvariantCultureIgnoreCase))
{
return(HealthCheckResult.Healthy("Got expected response from Speaker Api."));
}
return(HealthCheckResult.Unhealthy($"Got status code {response.StatusCode} with reason `{response.ReasonPhrase}`."));
}
catch (HttpRequestException httpRequestException)
{
return(HealthCheckResult.Unhealthy(httpRequestException.Message));
}
}
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
if (!IsCacheExpired())
{
return(Task.FromResult(_lastPingResult));
}
if (Monitor.TryEnter(_locker))
{
try
{
if (IsCacheExpired())
{
PingService();
}
}
finally
{
Monitor.Exit(_locker);
}
}
return(Task.FromResult(_lastPingResult));
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
foreach (var item in _options.ConfigureHosts.Values)
{
var ipAddresses = await Dns.GetHostAddressesAsync(item.Host).WithCancellationTokenAsync(cancellationToken);
foreach (var ipAddress in ipAddresses)
{
if (item.Resolutions == null || !item.Resolutions.Contains(ipAddress.ToString()))
{
return(new HealthCheckResult(context.Registration.FailureStatus, description: $"Ip Address {ipAddress} was not resolved from host {item.Host}"));
}
}
}
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
if (!Connections.TryGetValue(connectionString, out var cosmosDbClient))
{
cosmosDbClient = new CosmosClient(connectionString);
if (!Connections.TryAdd(connectionString, cosmosDbClient))
{
cosmosDbClient.Dispose();
cosmosDbClient = Connections[connectionString];
}
}
await cosmosDbClient.ReadAccountAsync();
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
/// <summary>
/// Perform a query to check how many holidays are registered in the Holidays table in current year.
/// </summary>
/// <param name="context">Represent the context information associated.</param>
/// <param name="cancellationToken">Notification that operations should be canceled.</param>
/// <returns><see cref="HealthCheckResult"/>The result of a health check</returns>
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken())
{
try
{
DateTime startDate = new DateTime(DateTime.Now.Year, 01, 01);
DateTime endDate = new DateTime(DateTime.Now.Year, 12, 31);
using (var connection = new SqlConnection(_connection))
{
await connection.OpenAsync(cancellationToken);
var command = connection.CreateCommand();
command.CommandText = $"select count(id) from holidays where holidaydate >= '{startDate.ToSqlDate()}' and holidaydate <= '{endDate.ToSqlDate()}'";
var x = Convert.ToInt32(await command.ExecuteScalarAsync(cancellationToken)) > 0 ? HealthCheckResult.Healthy() : HealthCheckResult.Unhealthy();
return(Convert.ToInt32(await command.ExecuteScalarAsync(cancellationToken)) > 0 ? HealthCheckResult.Healthy() : HealthCheckResult.Unhealthy());
}
}
catch (Exception ex)
{
return(HealthCheckResult.Unhealthy());
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken)
{
_logger.LogInformation("Pinging Courses API");
var timer = Stopwatch.StartNew();
var response = await _apiClient.GetResponseCode(new GetPingRequest());
timer.Stop();
if ((int)response == 200)
{
var durationString = timer.Elapsed.ToHumanReadableString();
_logger.LogInformation($"Courses API ping successful and took {durationString}");
return(HealthCheckResult.Healthy(HealthCheckResultDescription,
new Dictionary <string, object> {
{ "Duration", durationString }
}));
}
_logger.LogWarning($"Courses API ping failed : [Code: {response}]");
return(HealthCheckResult.Unhealthy(HealthCheckResultDescription));
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
foreach (var(host, port) in _options.ConfiguredHosts)
{
using (var tcpClient = new TcpClient())
{
await tcpClient.ConnectAsync(host, port).WithCancellationTokenAsync(cancellationToken);
if (!tcpClient.Connected)
{
return(new HealthCheckResult(context.Registration.FailureStatus, description: $"Connection to host {host}:{port} failed"));
}
}
}
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
if (_options.RegistryWriteCheck)
{
await ExecuteRegistryWriteCheckAsync(cancellationToken);
}
else if (_options.RegistryReadCheck)
{
await ExecuteRegistryReadCheckAsync();
}
if (_options.ServiceConnectionCheck)
{
await ExecuteServiceConnectionCheckAsync(cancellationToken);
}
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
using (var connection = new NpgsqlConnection(_connectionString))
{
_connectionAction?.Invoke(connection);
await connection.OpenAsync(cancellationToken);
using (var command = connection.CreateCommand())
{
command.CommandText = _sql;
await command.ExecuteScalarAsync(cancellationToken);
}
return(HealthCheckResult.Healthy());
}
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
using (var httpClient = new HttpClient()
{
BaseAddress = _idSvrUri
})
{
var response = await httpClient.GetAsync(IDSVR_DISCOVER_CONFIGURATION_SEGMENT);
if (!response.IsSuccessStatusCode)
{
return(new HealthCheckResult(context.Registration.FailureStatus, description: "Discover endpoint is not responding with 200 OK, the current status is {response.StatusCode} and the content { (await response.Content.ReadAsStringAsync())}"));
}
return(HealthCheckResult.Healthy());
}
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
var eventStoreUri = new Uri(_eventStoreConnection);
ConnectionSettings connectionSettings;
if (string.IsNullOrEmpty(_login) || string.IsNullOrEmpty(_password))
{
connectionSettings = ConnectionSettings.Create()
.KeepRetrying()
.Build();
}
else
{
connectionSettings = ConnectionSettings.Create()
.KeepRetrying()
.SetDefaultUserCredentials(new UserCredentials(_login, _password))
.Build();
}
var connection = EventStoreConnection.Create(
connectionSettings,
eventStoreUri,
CONNECTION_NAME);
await connection.ConnectAsync();
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken())
{
try
{
var connection = new SqlConnection(_configuration.GetConnectionString("ContentContext"));
await connection.OpenAsync(cancellationToken);
var command = new SqlCommand("SELECT TOP 1 * FROM Content", connection);
var reader = await command.ExecuteReaderAsync(cancellationToken);
var canRead = await reader.ReadAsync(cancellationToken);
connection.Close();
if (!canRead)
{
return(HealthCheckResult.Unhealthy());
}
return(HealthCheckResult.Healthy());
}
catch
{
return(HealthCheckResult.Unhealthy());
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
var configuredHosts = _options.ConfiguredHosts.Values;
try
{
foreach (var(host, timeout) in configuredHosts)
{
using var ping = new Ping();
var pingReply = await ping.SendPingAsync(host, timeout);
if (pingReply.Status != IPStatus.Success)
{
return(new HealthCheckResult(context.Registration.FailureStatus, description: $"Ping check for host {host} is failed with status reply:{pingReply.Status}"));
}
}
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken())
{
var query = GraphQueryBuilder.ForResourceType("microsoft.logic/workflows")
.Project("subscriptionId", "resourceGroup", "type", "name", "id")
.LimitTo(1)
.Build();
if (_resourceDeclarationMonitor.CurrentValue.AzureLandscape?.Subscriptions == null ||
_resourceDeclarationMonitor.CurrentValue.AzureLandscape?.Subscriptions?.Any() == false)
{
return(HealthCheckResult.Unhealthy("No Azure subscriptions are configured"));
}
var healthProbeResults = await ProbeSubscriptionsAsync(query);
var healthCheckMetadata = GenerateMetadata(healthProbeResults);
if (healthProbeResults.Any(probeKeyValuePair => probeKeyValuePair.IsSuccessful == false))
{
return(HealthCheckResult.Unhealthy("One or more subscriptions are unhealthy.", data: healthCheckMetadata));
}
return(HealthCheckResult.Healthy("Successfully queried all subscriptions", data: healthCheckMetadata));
}
/// <inheritdoc cref="IHealthCheck.CheckHealthAsync" />
public async Task <HealthCheckResult> CheckHealthAsync(
HealthCheckContext context,
CancellationToken cancellationToken = default)
{
Check.NotNull(context, nameof(context));
IReadOnlyCollection <IConsumer> disconnectedConsumers =
await _service.GetDisconnectedConsumersAsync(_minHealthyStatus, _gracePeriod, _endpointsFilter)
.ConfigureAwait(false);
if (disconnectedConsumers.Count == 0)
{
return(new HealthCheckResult(HealthStatus.Healthy));
}
string errorMessage = disconnectedConsumers.Aggregate(
"One or more consumers are not connected:",
(current, consumer) =>
$"{current}{Environment.NewLine}- " +
$"{consumer.Endpoint.DisplayName} " +
$"[{consumer.Id}]");
return(new HealthCheckResult(context.Registration.FailureStatus, errorMessage));
}
public async Task <HealthCheckResult> CheckHealthAsync(
HealthCheckContext context,
CancellationToken cancellationToken = default)
{
string faurl = Configuration["AppSettings:SAMPLE_VARIABLE"];
using (HttpClient client = new HttpClient())
{
try
{
var response = await client.GetAsync(faurl);
if (!response.IsSuccessStatusCode)
{
throw new Exception($"SAMPLE_VARIABLE responding with: {response.StatusCode}");
}
}
catch (Exception e)
{
return(await Task.FromResult(HealthCheckResult.Unhealthy(e.Message)));
}
}
return(await Task.FromResult(HealthCheckResult.Healthy("SAMPLE_VARIABLE endpoint is up!")));
}
/// <summary>
/// Runs the health check, returning the status of the component being checked.
/// </summary>
/// <param name="context">A context object associated with the current execution.</param>
/// <param name="cancellationToken">A <see cref="T:System.Threading.CancellationToken" /> that can be used to cancel the health check.</param>
/// <returns>A <see cref="T:System.Threading.Tasks.Task`1" /> that completes when the health check has finished, yielding the status of the component being checked.</returns>
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken())
{
try
{
var client = _workerProvider.CreateClient(_id);
var response = client.DnsLookup(new DnsLookupRequest
{
Host = "example.com",
Type = DnsLookupType.A,
}, cancellationToken: cancellationToken);
// Read the stream until the end
await foreach (var _ in response.ResponseStream.ReadAllAsync(cancellationToken))
{
}
_workerProvider.SetStatus(_id, WorkerStatus.Available);
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
_workerProvider.SetStatus(_id, WorkerStatus.Down);
return(HealthCheckResult.Unhealthy("DNS lookups failing", ex));
}
}
