public static HealthCheckBuilder AddValueTaskCheck(this HealthCheckBuilder builder, string name,
Func <ValueTask <IHealthCheckResult> > check)
{
Guard.ArgumentNotNull(nameof(builder), builder);
return(builder.AddCheck(name, HealthCheck.FromValueTaskCheck(check), builder.DefaultCacheDuration));
}
public static HealthCheckBuilder AddSqlCheck(this HealthCheckBuilder builder, string name, string connectionString, TimeSpan cacheDuration)
{
builder.AddCheck($"SqlCheck({name})", async() =>
{
try
{
//TODO: There is probably a much better way to do this.
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
using (var command = connection.CreateCommand())
{
command.CommandType = CommandType.Text;
command.CommandText = "SELECT 1";
var result = (int)await command.ExecuteScalarAsync().ConfigureAwait(false);
if (result == 1)
{
return(HealthCheckResult.Healthy($"SqlCheck({name}): Healthy"));
}
return(HealthCheckResult.Unhealthy($"SqlCheck({name}): Unhealthy"));
}
}
}
catch (Exception ex)
{
return(HealthCheckResult.Unhealthy($"SqlCheck({name}): Exception during check: {ex.GetType().FullName}"));
}
}, cacheDuration);
return(builder);
}
// Type versions of AddCheck
public static HealthCheckBuilder AddCheck <TCheck>(this HealthCheckBuilder builder, string name)
where TCheck : class, IHealthCheck
{
Guard.ArgumentNotNull(nameof(builder), builder);
return(builder.AddCheck <TCheck>(name, builder.DefaultCacheDuration));
}
public static HealthCheckBuilder AddCheck(this HealthCheckBuilder builder, string name,
Func <CancellationToken, IHealthCheckResult> check)
{
Guard.ArgumentNotNull(nameof(builder), builder);
return(builder.AddCheck(name, HealthCheck.FromCheck(check), builder.DefaultCacheDuration));
}
public static HealthCheckBuilder AddAzureTableStorageCheck(HealthCheckBuilder builder,
CloudStorageAccount storageAccount, string tableName = null, TimeSpan?cacheDuration = null)
{
builder.AddCheck($"AzureTableStorageCheck {storageAccount.TableStorageUri} {tableName}", async() =>
{
bool result;
try
{
var tableClient = storageAccount.CreateCloudTableClient();
var properties = await tableClient.GetServicePropertiesAsync().ConfigureAwait(false);
if (!string.IsNullOrWhiteSpace(tableName))
{
var table = tableClient.GetTableReference(tableName);
result = await table.ExistsAsync();
}
result = true;
}
catch (Exception)
{
result = false;
}
return(result
? HealthCheckResult.Healthy($"AzureTableStorage {storageAccount.BlobStorageUri} is available")
: HealthCheckResult.Unhealthy(
$"AzureTableStorage {storageAccount.BlobStorageUri} is unavailable"));
}, cacheDuration ?? builder.DefaultCacheDuration);
return(builder);
}
public static HealthCheckBuilder AddValueTaskCheck(this HealthCheckBuilder builder, string name,
Func <CancellationToken, ValueTask <IHealthCheckResult> > check, TimeSpan cacheDuration)
{
Guard.ArgumentNotNull(nameof(builder), builder);
return(builder.AddCheck(name, HealthCheck.FromValueTaskCheck(check), cacheDuration));
}
public static HealthCheckBuilder AddRedisCheck(this HealthCheckBuilder builder, string name, TimeSpan cacheDuration, string connectionString)
{
builder.AddCheck($"RedisCheck({name})", () =>
{
try
{
using (ConnectionMultiplexer connect = ConnectionMultiplexer.Connect(ConfigurationOptions.Parse(connectionString)))
{
var response = connect.GetStatus();
if (response != null && response.Any())
{
return(HealthCheckResult.Healthy($"Healthy"));
}
return(HealthCheckResult.Unhealthy($"Unhealthy"));
}
}
catch (Exception ex)
{
return(HealthCheckResult.Unhealthy($"{ex.GetType().FullName}"));
}
}, cacheDuration);
return(builder);
}
public static HealthCheckBuilder AddRedisCheck(this HealthCheckBuilder builder, string name, TimeSpan cacheDuration, ConcurrentDictionary <string, ConnectionMultiplexer> connectionCache)
{
builder.AddCheck($"RedisCheck({name})", () =>
{
try
{
var factory = new DefaultLoadBalancerFactory <ConnectionMultiplexer>();
var loadBalancer = factory.Resolve(() =>
{
return(connectionCache.Values.ToList());
});
var connect = loadBalancer.Resolve();
var response = connect.GetStatus();
if (response != null && response.Any())
{
return(HealthCheckResult.Healthy($"Healthy"));
}
return(HealthCheckResult.Unhealthy($"Unhealthy"));
}
catch (Exception ex)
{
return(HealthCheckResult.Unhealthy($"{ex.GetType().FullName}"));
}
}, cacheDuration);
return(builder);
}
public static HealthCheckBuilder AddMySQLCheck(this HealthCheckBuilder builder, string name, string connectionString, TimeSpan cacheDuration)
{
builder.AddCheck($"MySqlCheck({name})", async() =>
{
try
{
//TODO: There is probably a much better way to do this.
using (var connection = new MySqlConnection(connectionString))
{
connection.Open();
using (var cmd = new MySqlCommand("SHOW STATUS", connection))
{
var result = await cmd.ExecuteReaderAsync();
if (result.HasRows)
{
return(HealthCheckResult.Healthy($"MySqlCheck({name}): Healthy"));
}
return(HealthCheckResult.Unhealthy($"MySqlCheck({name}): Unhealthy"));
}
return(HealthCheckResult.Unhealthy($"MySqlCheck({name}): Unhealthy"));
}
}
catch (Exception ex)
{
return(HealthCheckResult.Unhealthy($"MySqlCheck({name}): Exception during check: {ex.GetType().FullName}"));
}
}, cacheDuration);
return(builder);
}
public static HealthCheckBuilder AddKafkaCheck(this HealthCheckBuilder healthCheckBuilder,
string bootstrapServers, string topic, TimeSpan?cacheDuration = null)
{
healthCheckBuilder.AddCheck("Kafka",
new KafkaCheck(bootstrapServers, topic),
cacheDuration.HasValue ? cacheDuration.Value : DefaulCacheDuration);
return(healthCheckBuilder);
}
public static HealthCheckBuilder AddMongoCheck(this HealthCheckBuilder healthCheckBuilder,
string connectionString, string database, IEnumerable <string> collections,
MongoDatabaseSettings databaseSettings = null, TimeSpan?cacheDuration = null)
{
healthCheckBuilder.AddCheck("Mongo",
new MongoCheck(connectionString, database, collections, databaseSettings),
cacheDuration.HasValue ? cacheDuration.Value : DefaulCacheDuration);
return(healthCheckBuilder);
}
public static HealthCheckBuilder AddUrlCheck(this HealthCheckBuilder builder, string url,
Func <HttpResponseMessage, ValueTask <IHealthCheckResult> > checkFunc,
TimeSpan cacheDuration)
{
Guard.ArgumentNotNull(nameof(builder), builder);
Guard.ArgumentNotNullOrEmpty(nameof(url), url);
Guard.ArgumentNotNull(nameof(checkFunc), checkFunc);
var urlCheck = new UrlChecker(checkFunc, url);
builder.AddCheck($"UrlCheck({url})", () => urlCheck.CheckAsync(), cacheDuration);
return(builder);
}
public static HealthCheckBuilder AddRedisCheck(this HealthCheckBuilder builder,
RedisCacheOptions options,
TimeSpan duration)
{
if (options == null)
{
CustomLogs.SetupCustomLogs.Logger().Warning("REDIS cache is disabled (RedisCacheOptions options is null)");
return(builder);
}
var key = $"redisHealthCheck_{Guid.NewGuid()}";
builder.AddCheck($"RedisCheck({options.InstanceName})", async() =>
{
try
{
using (var client = new RedisCache(options))
{
string data = Guid.NewGuid().ToString();
await client.SetAsync(key, data.ToByteArray(), new DistributedCacheEntryOptions()
{
AbsoluteExpirationRelativeToNow = duration
});
var response = client.Get(key);
if (response != null && response.FromByteArray <string>() == data)
{
return(HealthCheckResult.Healthy($"RedisCheck({options.InstanceName}): Healthy"));
}
return(HealthCheckResult.Unhealthy($"RedisCheck({options.InstanceName}): Unhealthy"));
}
}
catch (Exception ex)
{
return(HealthCheckResult.Unhealthy($"RedisCheck({options.InstanceName}): Exception during check: {ex.GetType().FullName}"));
}
}, duration);
return(builder);
}
public static HealthCheckBuilder AddMaxValueCheck <T>(this HealthCheckBuilder builder, string name, T maxValue, Func <T> currentValueFunc, TimeSpan cacheDuration)
where T : IComparable <T>
{
Guard.ArgumentNotNull(nameof(builder), builder);
Guard.ArgumentNotNullOrEmpty(nameof(name), name);
Guard.ArgumentNotNull(nameof(currentValueFunc), currentValueFunc);
builder.AddCheck(name, () =>
{
var currentValue = currentValueFunc();
var status = currentValue.CompareTo(maxValue) <= 0 ? CheckStatus.Healthy : CheckStatus.Unhealthy;
return(HealthCheckResult.FromStatus(
status,
$"max={maxValue}, current={currentValue}",
new Dictionary <string, object> {
{ "max", maxValue }, { "current", currentValue }
}
));
}, cacheDuration);
return(builder);
}
public static HealthCheckBuilder AddCosmosDbCheck(this HealthCheckBuilder builder, Uri serviceEndpoint, string authKey, TimeSpan cacheDuration)
{
var checkName = $"CosmosDbCheck({serviceEndpoint})";
builder.AddCheck(checkName, async() =>
{
try
{
using (var documentClient = new DocumentClient(serviceEndpoint, authKey))
{
await documentClient.OpenAsync();
return(HealthCheckResult.Healthy($"{checkName}: Healthy"));
}
}
catch (Exception ex)
{
// Failed to connect to CosmosDB.
return(HealthCheckResult.Unhealthy($"{checkName}: Exception during check: ${ex.Message}"));
}
}, cacheDuration);
return(builder);
}
public static HealthCheckBuilder AddMySQLCheck(this HealthCheckBuilder builder, string name, string connectionstring)
{
builder.AddCheck(name, new MySQLHealthCheck(connectionstring));
return(builder);
}
// IHealthCheck versions of AddCheck
public static HealthCheckBuilder AddCheck(this HealthCheckBuilder builder, string checkName, IHealthCheck check)
{
Guard.ArgumentNotNull(nameof(builder), builder);
return(builder.AddCheck(checkName, check, builder.DefaultCacheDuration));
}
internal override void RegisterChecks(HealthCheckBuilder checks)
{
checks
.AddCheck("Default", () => HealthCheckResult.Healthy("OK"))
.AddSqlCheck(connectionStringName, _connectionString);
}
public static HealthCheckBuilder AddMySQLCheck(this HealthCheckBuilder builder, string name, string connectionstring, TimeSpan cacheDuration)
{
builder.AddCheck(name, new MySQLHealthCheck(connectionstring), cacheDuration);
return(builder);
}
internal override void RegisterChecks(HealthCheckBuilder checks)
{
checks.AddCheck("Default", () => HealthCheckResult.Healthy("OK"));
}
