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); }