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 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 AddSqlCheck(this HealthCheckBuilder builder, string name,
string connectionString)
{
Guard.ArgumentNotNull(nameof(builder), builder);
return(AddSqlCheck(builder, name, connectionString, builder.DefaultCacheDuration));
}
// Numeric checks
public static HealthCheckBuilder AddMinValueCheck <T>(this HealthCheckBuilder builder, string name, T minValue,
Func <T> currentValueFunc) where T : IComparable <T>
{
Guard.ArgumentNotNull(nameof(builder), builder);
return(AddMinValueCheck(builder, name, minValue, currentValueFunc, builder.DefaultCacheDuration));
}
// 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));
}
// Func returning ValueTask<IHealthCheckResult>
public static HealthCheckBuilder AddUrlCheck(this HealthCheckBuilder builder, string url,
Func <HttpResponseMessage, ValueTask <IHealthCheckResult> > checkFunc)
{
Guard.ArgumentNotNull(nameof(builder), builder);
return(AddUrlCheck(builder, url, checkFunc, builder.DefaultCacheDuration));
}
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 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 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 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 IServiceCollection AddHealthChecks(this IServiceCollection services, Action <IHealthCheckBuilder> configureHealthCheckBuilder, IAsyncPolicy <HttpResponseMessage>[] policies)
{
if (configureHealthCheckBuilder == null)
{
throw new ArgumentNullException(nameof(configureHealthCheckBuilder));
}
if (policies == null)
{
throw new ArgumentNullException(nameof(policies));
}
var httpClient = services
.AddHttpClient <IHealthCheckHttpClient, HealthCheckHttpClient>()
.AddPolicyHandlers(policies);
services.AddTransient <IHealthCheckService, HealthCheckService>();
var builder = new HealthCheckBuilder();
configureHealthCheckBuilder(builder);
foreach (var factory in builder.GetAll())
{
services.AddTransient(sp => factory(sp));
}
return(services);
}
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);
}
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 AddAzureTableStorageCheck(this HealthCheckBuilder builder, string accountName,
string accountKey, string tableName = null, TimeSpan?cacheDuration = null)
{
var credentials = new StorageCredentials(accountName, accountKey);
var storageAccount = new CloudStorageAccount(credentials, true);
return(AddAzureTableStorageCheck(builder, storageAccount, tableName, cacheDuration));
}
public static HealthCheckBuilder AddUrlCheck(this HealthCheckBuilder builder, string url,
Func <HttpResponseMessage, Task <IHealthCheckResult> > checkFunc,
TimeSpan cacheDuration)
{
Guard.ArgumentNotNull(nameof(checkFunc), checkFunc);
return(AddUrlCheck(builder, url, response => new ValueTask <IHealthCheckResult>(checkFunc(response)), cacheDuration));
}
public static HealthCheckBuilder AddUrlCheckIfNotNull(this HealthCheckBuilder builder, string url, TimeSpan cacheDuration)
{
if (!string.IsNullOrEmpty(url))
{
builder.AddUrlCheck(url, cacheDuration);
}
return(builder);
}
public static HealthCheckBuilder AddUrlCheckIfNotNull(this HealthCheckBuilder builder, string url)
{
if (!string.IsNullOrEmpty(url))
{
builder.AddUrlCheck(url);
}
return(builder);
}
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 IServiceCollection AddHealthChecks(this IServiceCollection services, Action <HealthCheckBuilder> checkupAction)
{
var checkupBuilder = new HealthCheckBuilder();
checkupAction.Invoke(checkupBuilder);
services.AddSingleton(checkupBuilder);
services.AddSingleton <IHealthCheckService, HealthCheckService>();
return(services);
}
public static void Build(Action <HealthCheckBuilder> buildout, IServiceProvider serviceProvider, IServiceScopeFactory serviceScopeFactory)
{
Guard.ArgumentNotNull(nameof(buildout), buildout);
Guard.OperationValid(_service == null, "You may only call Build once.");
var builder = new HealthCheckBuilder();
buildout(builder);
_service = new HealthCheckService(builder, serviceProvider ?? new NoOpServiceProvider(), serviceScopeFactory);
}
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 AddSmtpCheck(this HealthCheckBuilder builder, IConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
var options = new SmtpCheckOptions();
configuration.Bind(options);
return(builder.AddSmtpCheck(options));
}
public static IServiceCollection AddHealth(this IServiceCollection services, Action <HealthCheckBuilder> configureBuilder)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
services.AddHealth();
var builder = new HealthCheckBuilder(services);
configureBuilder(builder);
services.AddSingleton <IHealthCheckPolicyProvider>(new DefaultHealthCheckPolicyProvider(builder.Build()));
return(services);
}
public static IServiceCollection AddHealthChecks(this IServiceCollection services, Action <HealthCheckBuilder> checks)
{
Guard.OperationValid(!services.Any(descriptor => descriptor.ServiceType == HealthCheckServiceInterface), "AddHealthChecks may only be called once.");
var builder = new HealthCheckBuilder();
services.TryAddSingleton <IHealthCheckService>(serviceProvider =>
{
var serviceScopeFactory = serviceProvider.GetService <IServiceScopeFactory>();
return(new HealthCheckService(builder, serviceProvider, serviceScopeFactory));
});
checks(builder);
return(services);
}
public static HealthCheckBuilder AddRedisCheck(this HealthCheckBuilder builder, string name, Action <RedisCheckSettingsBuilder> configureAction)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (configureAction == null)
{
throw new ArgumentNullException(nameof(configureAction));
}
var buider = new RedisCheckSettingsBuilder(name);
configureAction(buider);
var settings = buider.Build();
return(builder.Add <RedisCheck>(settings));
}
/// <summary>
/// Adds services required for health check.
/// </summary>
/// <param name="services">The services collection</param>
/// <param name="builder">The configuration builder</param>
/// <returns>The service collection after changes</returns>
public static IServiceCollection AddHealthCheck(this IServiceCollection services, Action <IHealthCheckBuilder> builder)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var cfg = new HealthCheckBuilder();
builder(cfg);
cfg.RegisterDescriptors(services);
return(services);
}
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);
}
