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