public JsonOutputFormatterTests(ITestOutputHelper output) { _output = output; _formatter = new HealthStatusJsonOutputFormatter(DefaultJsonSerializerSettings.CreateSerializerSettings()); var healthyOne = new HealthCheck.Result("test_one_healthy", HealthCheckResult.Healthy("first check was good")); var healthyTwo = new HealthCheck.Result("test_two_healthy", HealthCheckResult.Healthy("second check was good")); var unhealthyOne = new HealthCheck.Result("test_three_unhealthy", HealthCheckResult.Unhealthy("something failed")); var unhealthyTwo = new HealthCheck.Result("test_four_unhealthy", HealthCheckResult.Unhealthy("something else failed")); var degradedOne = new HealthCheck.Result("test_five_degraded", HealthCheckResult.Degraded("degrading service")); var checks = new[] { healthyOne, healthyTwo, unhealthyOne, unhealthyTwo, degradedOne }; _healthStatus = new HealthStatus(checks); }
public override async Task <HealthCheckResult> DoCheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { var adminUsername = config.Get(ConfigNames.AdminUsername); var cacheKey = CacheKeys.FailedLoginRequests; var attempts = await cache.TryGetAsync <int>(cacheKey.Name(adminUsername)); var message = $"There are {attempts.Value} login attempts for the admin user in the last {cacheKey.TimeToLive} hours"; if (attempts.Success && attempts.Value >= LoginController.MaxLoginTries) { return(HealthCheckResult.Degraded(message)); } return(HealthCheckResult.Healthy(message)); }
/// <summary> /// Checks the current health state using the gateway Status property. /// </summary> /// <param name="context"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { var parameter = _accessor?.HttpContext?.Request?.Query["time"].ToString(); int time = _settings.Roundtrip; if (!string.IsNullOrEmpty(parameter) && int.TryParse(parameter, out int value)) { time = (value > 0) ? value : time; } try { Ping sender = new Ping(); var options = new PingOptions(_settings.Ttl, _settings.DontFragment); var buffer = Encoding.ASCII.GetBytes(new string('x', 56)); var reply = sender.Send(_settings.Host, _settings.Timeout, buffer, options); if (reply.Status == IPStatus.Success) { if (reply.RoundtripTime > time) { return(Task.FromResult(HealthCheckResult.Degraded($"Gateway ping OK ({reply.RoundtripTime} msec)", null, new Dictionary <string, object>() { { "Status", reply.Status } }))); } return(Task.FromResult(HealthCheckResult.Healthy("Gateway ping OK", new Dictionary <string, object>() { { "Status", reply.Status } }))); } else { return(Task.FromResult(HealthCheckResult.Unhealthy("Gateway ping not OK", null, new Dictionary <string, object>() { { "Status", reply.Status } }))); } } catch (PingException pex) { return(Task.FromResult(HealthCheckResult.Unhealthy("Gateway ping exception", pex))); } }
public void ConfigureServices(IServiceCollection services) { var isLive = true; services.AddHealthChecks() .AddCheck( "live", () => { return(isLive ? HealthCheckResult.Healthy() : HealthCheckResult.Unhealthy()); }) .AddMySql( Configuration["ConnectionString"], "mysql") .AddCheck( "his", () => { return(HealthCheckResult.Degraded()); }); services.AddControllers(); }
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { var manager = client.GetGrain <IManagementGrain>(0); try { var hosts = await manager.GetHosts(); var count = hosts.Values.Where(x => x.IsUnavailable()).Count(); return(count > 0 ? HealthCheckResult.Degraded($"{count} silo(s) unavailable") : HealthCheckResult.Healthy()); } catch (Exception error) { return(HealthCheckResult.Unhealthy("Failed to get cluster status", error)); } }
public HealthCheckResult GenerateRandomResult() { int value = random.Next(100); switch (value) { case int n when(n >= 80): return(HealthCheckResult.Unhealthy()); case int n when(n >= 50): return(HealthCheckResult.Degraded()); default: return(HealthCheckResult.Healthy()); } }
protected override Task <HealthCheckResult> CheckAsync(CancellationToken token = default(CancellationToken)) { int second = DateTime.Now.Second; switch (second % 3) { case 0: return(Task.FromResult(HealthCheckResult.Healthy("OK"))); case 1: return(Task.FromResult(HealthCheckResult.Degraded("Degraded"))); default: return(Task.FromResult(HealthCheckResult.Unhealthy("不健康"))); } }
/// <inheritdoc /> protected override async ValueTask <HealthCheckResult> CheckAsync(CancellationToken cancellationToken = default) { await Task.Delay(TimeSpan.FromSeconds(6), cancellationToken); if (DateTime.UtcNow.Second <= 20) { return(HealthCheckResult.Degraded()); } if (DateTime.UtcNow.Second >= 40) { return(HealthCheckResult.Unhealthy()); } return(HealthCheckResult.Healthy()); }
public Task <HealthCheckResult> CheckAsync(CancellationToken cancellationToken) { var state = ThreadPoolUtility.GetPoolState(); if (state.UsedWorkerThreads >= state.MinWorkerThreads) { return(Task.FromResult(HealthCheckResult.Degraded($"Worker threads in thread pool are exhausted: {state.UsedWorkerThreads}/{state.MinWorkerThreads} (used/min)."))); } if (state.UsedIocpThreads >= state.MinIocpThreads) { return(Task.FromResult(HealthCheckResult.Degraded($"IOCP threads in thread pool are exhausted: {state.UsedIocpThreads}/{state.MinIocpThreads} (used/min)."))); } return(Task.FromResult(HealthCheckResult.Healthy())); }
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { try { using var ping = new Ping(); var reply = await ping.SendPingAsync(host); var description = $"ICMP to {host} took {reply.RoundtripTime} ms."; return(reply.Status switch { IPStatus.Success => reply.RoundtripTime > healthyRoundtripTime ? HealthCheckResult.Degraded(description) : HealthCheckResult.Healthy(description), _ => HealthCheckResult.Unhealthy($"ICMP to {host} failed: {reply.Status}"), }); }
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { var responseTime = _random.Next(1, 300); if (responseTime > 200) { return(Task.FromResult(HealthCheckResult.Unhealthy($"The response time is unacceptable ({responseTime})"))); } if (responseTime > 100) { return(Task.FromResult(HealthCheckResult.Degraded($"The response time is a bit slow ({responseTime})"))); } return(Task.FromResult(HealthCheckResult.Healthy($"The response time looks good ({responseTime})"))); }
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { var nowSecs = DateTime.UtcNow.Second; if (nowSecs % 2 == 0) { return(Task.FromResult(HealthCheckResult.Healthy())); } if (nowSecs % 3 == 0) { return(Task.FromResult(HealthCheckResult.Degraded())); } return(Task.FromResult(HealthCheckResult.Unhealthy())); }
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { try { _connection ??= CreateConnection(_options); if (_connection is null) { throw new ArgumentNullException(nameof(_connection)); } var healthCheckResult = GetHealthCheckResultFromState(_connection); return(Task.FromResult(healthCheckResult)); } catch (Exception ex) { var unhealthy = new HealthCheckResult(context.Registration.FailureStatus, exception: ex); return(Task.FromResult(unhealthy)); } IConnection CreateConnection(NatsOptions options) { if (!string.IsNullOrWhiteSpace(options.CredentialsPath)) { return(_connectionFactory.CreateConnection(options.Url, options.CredentialsPath)); } if (!string.IsNullOrWhiteSpace(options.Jwt) && !string.IsNullOrWhiteSpace(options.PrivateNKey)) { return(_connectionFactory.CreateConnection(options.Url, options.Jwt, options.PrivateNKey)); } return(_connectionFactory.CreateConnection(options.Url)); } HealthCheckResult GetHealthCheckResultFromState(IConnection connection) { string description = GetDescription(connection); return(connection.State switch { ConnState.CONNECTED => HealthCheckResult.Healthy(description, GetStatsData(connection)), ConnState.CONNECTING or ConnState.RECONNECTING or ConnState.DRAINING_SUBS or ConnState.DRAINING_PUBS => HealthCheckResult.Degraded(description), ConnState.CLOSED or ConnState.DISCONNECTED => HealthCheckResult.Unhealthy(description), _ => new HealthCheckResult(context.Registration.FailureStatus, description), }); }
private static ValueTask <HealthCheckResult> ExecuteSqlCheckAsync( string name, Func <IDbConnection> newDbConnection, TimeSpan timeout, bool degradedOnError, CancellationToken cancellationToken) { var sw = new Stopwatch(); try { using (var tokenWithTimeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken)) { tokenWithTimeout.CancelAfter(timeout); sw.Start(); using (var connection = newDbConnection()) { if (connection.State == ConnectionState.Closed) { connection.Open(); } using (var command = connection.CreateCommand()) { command.CommandType = CommandType.Text; command.CommandText = "SELECT 1"; var commandResult = Convert.ToInt64(command.ExecuteScalar()); var result = commandResult == 1 ? HealthCheckResult.Healthy($"OK. {name}.") : HealthCheckResultOnError($"FAILED. {name} SELECT failed. Time taken: {sw.ElapsedMilliseconds}ms.", degradedOnError); return(new ValueTask <HealthCheckResult>(result)); } } } } catch (Exception ex) { var failedResult = degradedOnError ? HealthCheckResult.Degraded(ex) : HealthCheckResult.Unhealthy(ex); return(new ValueTask <HealthCheckResult>(failedResult)); } }
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { int responseTimeInMs = rdn.Next(1, 300); if (responseTimeInMs < 100) { return(Task.FromResult(HealthCheckResult.Healthy($"The response time looks good ({ responseTimeInMs }ms)."))); } else if (responseTimeInMs < 200) { return(Task.FromResult(HealthCheckResult.Degraded($"The response time is a bit slow ({ responseTimeInMs }ms)."))); } else { return(Task.FromResult(HealthCheckResult.Unhealthy($"The response time is unacceptable ({ responseTimeInMs }ms)."))); } }
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default(CancellationToken)) { CircuitBreakerPolicy policy; HealthCheckResult result = HealthCheckResult.Healthy(); foreach (string name in options.Value.CircuitBreakerNames) { if (registry.TryGet <CircuitBreakerPolicy>(name, out policy)) { if (policy.CircuitState == CircuitState.Isolated || policy.CircuitState == CircuitState.HalfOpen) { result = HealthCheckResult.Degraded(description: "Too many circuit breakers are (half)open."); } } } return(Task.FromResult(result)); }
public static void Main() { var random = new Random(); Host.CreateDefaultBuilder() .ConfigureWebHostDefaults(builder => builder.ConfigureServices(svcs => svcs.AddHealthChecks() .AddCheck("default", Check)).Configure(app => app.UseHealthChecks("/healthcheck"))) .Build() .Run(); HealthCheckResult Check() => (random.Next(1, 4)) switch { 1 => HealthCheckResult.Unhealthy(), 2 => HealthCheckResult.Degraded(), _ => HealthCheckResult.Healthy(), }; }
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken()) { if (_hostEnvironmentStatistics.CpuUsage > UnhealthyThreshold) { return(Task.FromResult(HealthCheckResult.Unhealthy( $"CPU utilization is unhealthy at {_hostEnvironmentStatistics.CpuUsage}%."))); } if (_hostEnvironmentStatistics.CpuUsage > DegradedThreshold) { return(Task.FromResult(HealthCheckResult.Degraded( $"CPU utilization is degraded at {_hostEnvironmentStatistics.CpuUsage}%."))); } return(Task.FromResult(HealthCheckResult.Healthy( $"CPU utilization is healthy at {_hostEnvironmentStatistics.CpuUsage}%."))); }
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { var(IsHealthy, time) = await CheckConnection(); if (IsHealthy) { if (time > 10) { return(HealthCheckResult.Degraded("Connection Is Poor")); } return(HealthCheckResult.Healthy("healthed")); } else { return(HealthCheckResult.Unhealthy("Unhealthy")); } }
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default(CancellationToken)) { try { var forcast = await _weatherService.GetDailyForeCastAsync(_testableCoordinates); if (forcast.Forecasts.Any()) { return(HealthCheckResult.Healthy()); } return(HealthCheckResult.Degraded()); } catch (Exception ex) { return(HealthCheckResult.Degraded(nameof(IWeatherService), ex)); } }
public async Task Status_is_degraded_if_one_check_is_degraded() { // Arrange var checks = new[] { new HealthCheck("ok", () => new ValueTask <HealthCheckResult>(HealthCheckResult.Healthy())), new HealthCheck("degraded", () => new ValueTask <HealthCheckResult>(HealthCheckResult.Degraded())) }; var runner = new DefaultHealthCheckRunner(checks); // Act var status = await runner.ReadAsync(); // Assert status.Status.Should().Be(HealthCheckStatus.Degraded); status.Results.Count().Should().Be(2); }
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { var description = $"{typeof(CourseCurrentOpportunitiesRefresh).Namespace} - SearchKeywords used [{courseSearchSettings.HealthCheckKeyWords}]"; logger.LogInformation($"{nameof(CheckHealthAsync)} has been called - service {description}"); var result = await courseSearchApiService.GetCoursesAsync(courseSearchSettings.HealthCheckKeyWords).ConfigureAwait(false); if (result.Any()) { return(HealthCheckResult.Healthy(description)); } else { return(HealthCheckResult.Degraded(description)); } }
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { var description = $"{typeof(AVAPIService).Namespace} - Mappings used standards[{aVAPIServiceSettings.StandardsForHealthCheck}]"; logger.LogInformation($"{nameof(CheckHealthAsync)} has been called - service {description}"); var apprenticeshipVacancySummaryResponse = await GetAVSumaryPageAsync(new AVMapping { Standards = aVAPIServiceSettings.StandardsForHealthCheck.Split(',') }, 1).ConfigureAwait(false); if (apprenticeshipVacancySummaryResponse.Results.Any()) { return(HealthCheckResult.Healthy(description)); } else { return(HealthCheckResult.Degraded(description)); } }
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { int responseTimeMS = rnd.Next(1, 300); if (responseTimeMS < 100) { return(Task.FromResult(HealthCheckResult.Healthy($"The response time looks good ({responseTimeMS }"))); } else if (responseTimeMS < 200) { return(Task.FromResult(HealthCheckResult.Degraded($"The response time is a bit slow ({responseTimeMS }"))); } else { return(Task.FromResult(HealthCheckResult.Unhealthy($"The response time is too long ({responseTimeMS }"))); } }
public Task <HealthCheckResult> CheckHealthAsync( HealthCheckContext context, CancellationToken cancellationToken = default(CancellationToken)) { // Execute health check logic here. This example sets a dummy // variable to true. var healthCheckResultHealthy = true; if (healthCheckResultHealthy) { return(Task.FromResult( HealthCheckResult.Healthy("The check indicates a healthy result."))); } return(Task.FromResult( HealthCheckResult.Degraded("The check indicates an unhealthy result."))); }
public Task <HealthCheckResult> CheckHealthAsync( HealthCheckContext context, CancellationToken cancellationToken = default(CancellationToken)) { Debug.WriteLine("Executing StartupHealthCheck"); switch (this._statusSvc.HealthStatusStartup) { case HealthStatus.Unhealthy: return(Task.FromResult(HealthCheckResult.Unhealthy("Reported Unhealthy"))); case HealthStatus.Degraded: return(Task.FromResult(HealthCheckResult.Degraded("Reported Degraded"))); default: return(Task.FromResult(HealthCheckResult.Healthy("Reported Healthy"))); } }
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { try { var status = await _taxasClient.GetHealthCheck(cancellationToken); if (status == HealthStatus.Healthy) { return(HealthCheckResult.Healthy("Consulta de taxas está operacional")); } return(HealthCheckResult.Degraded("Consulta de taxas não está operacional")); } catch (Exception ex) { return(HealthCheckResult.Degraded("Consulta de taxas não está operacional", ex)); } }
public async Task <HealthCheckResult> CheckHealth() { var response = await _httpClient.GetAsync("/health"); if (!response.IsSuccessStatusCode) { return(HealthCheckResult.Unhealthy("CertServer reported Unhealthy")); } string content = await response.Content.ReadAsStringAsync(); if (content == nameof(HealthCheckResult.Degraded)) { return(HealthCheckResult.Degraded("CertServer reported Degraded")); } return(HealthCheckResult.Healthy()); }
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = new CancellationToken()) { var info = CommonUtils.GetStorageInfo(_path); var data = new Dictionary <string, object> { { "StorageTotalSize", info?.TotalSize }, { "StorageFreeSpace", info?.FreeSpace }, { "StorageFreeSpacePerc", info?.FreeSpacePerc } }; if (info != null && info.FreeSpacePerc <= _freeSpacePercWarningThreshold) { return(Task.FromResult(HealthCheckResult.Degraded("Low on available disk space", null, data))); } return(Task.FromResult(HealthCheckResult.Healthy("Free disk space is fine", data))); }
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default) { await Task.Delay(3000); var r = new Random(); var i = r.Next(3); switch (i) { case 1: return(HealthCheckResult.Healthy("")); case 2: return(HealthCheckResult.Degraded("")); case 3: return(HealthCheckResult.Unhealthy("")); default: return(HealthCheckResult.Unhealthy("")); } }