public async Task CheckHealth(CancellationToken cancellationToken, IMonitorSettings settings) { Logger.DebugFormat("Checking health of {0}...", this); var endpointHealth = await PerformHealthCheck(cancellationToken, settings); LogHealthStatus(endpointHealth); Health = endpointHealth; }
public Endpoint UpdateHealth(EndpointHealth health) { if (Health != null && Health.CheckTimeUtc > health.CheckTimeUtc) return this; Health = health; UpdateLastModifiedTime(); return this; }
public EndpointMetricsForwarderCoordinatorTest() { var endpointId = Guid.NewGuid(); var health = new EndpointHealth(DateTime.UtcNow, TimeSpan.FromSeconds(1), EndpointStatus.Healthy); _endpoint = new Endpoint(TimeCoordinatorMock.Get().Object, new EndpointIdentity(endpointId, "type", "Address"), new EndpointMetadata("Name", "Group", null, EndpointMetadata.DefaultMonitorTag, DateTime.UtcNow, DateTime.UtcNow)); _endpoint.UpdateHealth(health); _forwarder = new Mock<IEndpointMetricsForwarder>(); _duplicateForwarder = new Mock<IEndpointMetricsForwarder>(); }
public void CheckHealth_should_update_the_endpoint_with_its_health_status() { var endpoint = new Endpoint(Guid.Empty, MonitorMock.Mock("monitor"), "address", "name", "group"); var sampler = new Mock<IHealthSampler>(); var token = new CancellationToken(); var result = new EndpointHealth(DateTime.UtcNow, TimeSpan.Zero, EndpointStatus.Healthy); sampler.Setup(s => s.CheckHealth(endpoint, token)).Returns(Task.FromResult(result)); endpoint.CheckHealth(sampler.Object, token).Wait(); Assert.Same(result, endpoint.Health); }
public async Task CheckHealth_should_update_the_endpoint_with_its_health_status() { var endpoint = new MonitorableEndpoint(new EndpointIdentity(Guid.Empty, "monitor", "address"), MonitorMock.Mock("monitor")); var sampler = new Mock<IHealthSampler>(); var token = new CancellationToken(); var result = new EndpointHealth(DateTime.UtcNow, TimeSpan.Zero, EndpointStatus.Healthy); sampler.Setup(s => s.CheckHealthAsync(endpoint, token)).Returns(Task.FromResult(result)); await endpoint.CheckHealth(sampler.Object, token); Assert.Same(result, endpoint.Health); }
public void InsertEndpointStatistics(Guid endpointId, EndpointHealth stats) { using (var conn = _db.OpenConnection()) using (var tx = conn.BeginTransaction()) { conn.Execute( "insert into EndpointStats (EndpointId, CheckTimeUtc, ResponseTime, Status) values (@endpointId, @checkTimeUtc, @responseTime, @status)", new { endpointId, stats.CheckTimeUtc, responseTime = stats.ResponseTime.Ticks, stats.Status }, tx); tx.Commit(); } }
private void InsertStatistics(Guid id, EndpointHealth health) { try { _repository.InsertEndpointStatistics(id, health); } catch (Exception e) { Logger.Error($"Unable to insert endpoint statistics: {e}"); } }
public void RecordEndpointStatistics_should_save_statistics() { var repository = new Mock<IEndpointStatsRepository>(); var monitorSettings = new Mock<IMonitorSettings>(); var endpointHealth = new EndpointHealth(DateTime.UtcNow, TimeSpan.Zero, EndpointStatus.Offline); var endpointId = Guid.NewGuid(); using (var manager = new EndpointStatsManager(repository.Object, monitorSettings.Object)) manager.RecordEndpointStatistics(endpointId, endpointHealth); repository.Verify(r => r.InsertEndpointStatistics(endpointId, endpointHealth)); }
public void HandleMetricsForwarding(EndpointIdentity identity, EndpointMetadata metadata, EndpointHealth health) { var ed = new EndpointDetails(identity.Id, metadata.Group, metadata.Name, identity.Address, identity.MonitorType); var em = new EndpointMetrics(health.CheckTimeUtc, health.ResponseTime.Milliseconds, health.Status.ToString()); foreach (var f in _forwarders) { Logger.InfoFormat("Forwarding metrics using {0} forwarder, for endpoint id {1}", f.Key, identity.Id); f.Value.ForwardEndpointMetrics(ed, em); } }
public void UpdateHealth_should_update_health_and_last_modified_time() { var endpoint = new Endpoint(_timeCoordinator.Object, new EndpointIdentity(Guid.NewGuid(), "monitor", "address"), new EndpointMetadata("name", "group", null, EndpointMetadata.DefaultMonitorTag, DateTime.UtcNow, DateTime.UtcNow)); var health = new EndpointHealth(DateTime.UtcNow, TimeSpan.Zero, EndpointStatus.Healthy); var expectedLastModifiedTime = DateTime.UtcNow; _timeCoordinator.Setup(c => c.UtcNow).Returns(expectedLastModifiedTime); endpoint.UpdateHealth(health); Assert.Same(health, endpoint.Health); Assert.Equal(expectedLastModifiedTime, endpoint.LastModifiedTimeUtc); }
private void ReportEndpointTimeout(Endpoint endpoint) { try { var health = new EndpointHealth(_timeCoordinator.UtcNow, TimeSpan.Zero, EndpointStatus.TimedOut, new Dictionary<string, string> { { "reason", "Endpoint health was not updated within specified period of time." } }); _endpointRegistry.UpdateHealth(endpoint.Identity.Id, health); _logger.Warn($"Endpoint Id={endpoint.Identity.Id} health was not updated within specified period of time."); } catch (Exception e) { _logger.Error($"Unable to update endpoint Id={endpoint.Identity.Id} health.", e); } }
private void LogHealthStatus(EndpointHealth endpointHealth) { switch (endpointHealth.Status) { case EndpointStatus.TimedOut: case EndpointStatus.Unhealthy: Logger.WarnFormat("Status of {0}: Status={1}, ResponseTime={2}", this, endpointHealth.Status, endpointHealth.ResponseTime); break; case EndpointStatus.Faulty: Logger.ErrorFormat("Status of {0}: Status={1}, ResponseTime={2}, Details={3}", this, endpointHealth.Status, endpointHealth.ResponseTime, endpointHealth.PrettyFormatDetails()); break; default: Logger.InfoFormat("Status of {0}: Status={1}, ResponseTime={2}", this, endpointHealth.Status, endpointHealth.ResponseTime); break; } }
public void RecordEndpointStatistics_should_save_statistics() { var repository = new Mock<IEndpointStatsRepository>(); var monitorSettings = new Mock<IMonitorSettings>(); var endpointMetricsCoordinator = new Mock<IEndpointMetricsForwarderCoordinator>(); var endpointHealth = new EndpointHealth(DateTime.UtcNow, TimeSpan.Zero, EndpointStatus.Offline); var endpointId = Guid.NewGuid(); var endpoint = new Endpoint(TimeCoordinatorMock.Get().Object, new EndpointIdentity(endpointId, "type", "address"), new EndpointMetadata("name", "group", null, EndpointMetadata.DefaultMonitorTag, DateTime.UtcNow, DateTime.UtcNow)); using (var manager = new EndpointStatsManager(repository.Object, monitorSettings.Object, TimeCoordinatorMock.Get().Object, endpointMetricsCoordinator.Object)) { manager.RecordEndpointStatistics(endpoint.Identity, endpoint.Metadata, endpointHealth); } repository.Verify(r => r.InsertEndpointStatistics(endpointId, endpointHealth)); }
private static void LogHealthStatus(Endpoint endpoint, EndpointHealth endpointHealth) { switch (endpointHealth.Status) { case EndpointStatus.TimedOut: case EndpointStatus.Unhealthy: Logger.WarnFormat("Status of {0}: Status={1}, ResponseTime={2}", endpoint, endpointHealth.Status, endpointHealth.ResponseTime); break; case EndpointStatus.Faulty: Logger.ErrorFormat("Status of {0}: Status={1}, ResponseTime={2}, Details={3}", endpoint, endpointHealth.Status, endpointHealth.ResponseTime, endpointHealth.PrettyFormatDetails()); break; default: Logger.InfoFormat("Status of {0}: Status={1}, ResponseTime={2}", endpoint, endpointHealth.Status, endpointHealth.ResponseTime); break; } }
public void UpdateHealth_should_not_update_health_if_already_have_more_recent_result() { var expectedLastModifiedTime1 = DateTime.UtcNow; var expectedLastModifiedTime2 = DateTime.UtcNow.AddMinutes(1); var endpoint = new Endpoint(_timeCoordinator.Object, new EndpointIdentity(Guid.NewGuid(), "monitor", "address"), new EndpointMetadata("name", "group", null, EndpointMetadata.DefaultMonitorTag, DateTime.UtcNow, DateTime.UtcNow)); var newHealth = new EndpointHealth(DateTime.UtcNow, TimeSpan.Zero, EndpointStatus.Healthy); var oldHealth = new EndpointHealth(DateTime.UtcNow.AddSeconds(-1), TimeSpan.Zero, EndpointStatus.Healthy); _timeCoordinator.Setup(c => c.UtcNow).Returns(expectedLastModifiedTime1); endpoint.UpdateHealth(newHealth); _timeCoordinator.Setup(c => c.UtcNow).Returns(expectedLastModifiedTime2); endpoint.UpdateHealth(oldHealth); Assert.Same(newHealth, endpoint.Health); Assert.Equal(expectedLastModifiedTime1, endpoint.LastModifiedTimeUtc); }
public void UpdateHealth_should_update_health_and_save_it_in_repository() { SetupMonitors("monitor"); var id = _registry.RegisterOrUpdate("monitor", "address", "group", "name", null, null, "password"); var health = new EndpointHealth(DateTime.UtcNow, TimeSpan.Zero, EndpointStatus.Healthy); Assert.True(_registry.UpdateHealth(id, health)); _statsManager.Verify(r => r.RecordEndpointStatistics(It.IsAny<EndpointIdentity>(), It.IsAny<EndpointMetadata>(), health)); Assert.Same(_registry.GetById(id).Health, health); }
public void UpdateHealth_should_return_false_for_unknown_endpoints() { var health = new EndpointHealth(DateTime.UtcNow, TimeSpan.Zero, EndpointStatus.Healthy); var id = Guid.NewGuid(); Assert.False(_registry.UpdateHealth(id, health)); }
private static bool AssertHealth(EndpointHealth actual, HealthUpdate expected) { Assert.Equal(expected.CheckTimeUtc, actual.CheckTimeUtc); Assert.Equal(expected.ResponseTime, actual.ResponseTime); Assert.Equal(expected.Status, actual.Status); Assert.Equal(expected.Details, actual.Details); return true; }
public void GetEndpoint_should_return_endpoint_information_with_details(EndpointStatus status) { var id = Guid.NewGuid(); var endpoint = new Endpoint(TimeCoordinatorMock.Get().Object, new EndpointIdentity(id, "monitor", "address"), new EndpointMetadata("name", "group", new[] { "t1", "t2" }, EndpointMetadata.DefaultMonitorTag, DateTime.UtcNow, DateTime.UtcNow)); var endpointHealth = new EndpointHealth(_utcNow, TimeSpan.FromSeconds(5), status, new Dictionary<string, string> { { "abc", "def" } }); endpoint.UpdateHealth(endpointHealth); _endpointRegistry.Setup(r => r.GetById(id)).Returns(endpoint); var result = _controller.GetEndpoint(id) as OkNegotiatedContentResult<EndpointDetails>; Assert.NotNull(result); AssertEndpoint(endpoint, result.Content); Assert.Equal(status, result.Content.Status); Assert.Equal(endpointHealth.CheckTimeUtc, result.Content.LastCheckUtc); Assert.Equal(endpointHealth.ResponseTime, result.Content.LastResponseTime); Assert.Equal(endpointHealth.Details, result.Content.Details); }
public void RecordEndpointStatistics(Guid endpointId, EndpointHealth stats) { _statsQueue.Add(Tuple.Create(endpointId, stats)); }
public async Task CheckHealth(IHealthSampler sampler, CancellationToken cancellationToken) { Health = await sampler.CheckHealth(this, cancellationToken); }
public void RecordEndpointStatistics(EndpointIdentity identity, EndpointMetadata metadata, EndpointHealth stats) { _statsQueue.Enqueue(Tuple.Create(identity, metadata, stats)); }
public void UpdateHealth(Guid endpointId, EndpointHealth endpointHealth) { _outgoingQueue.Enqueue(new EndpointHealthUpdate(endpointId, endpointHealth)); }
private static void AssertCheckTime(EndpointHealth result) { var now = DateTime.UtcNow; var delta = TimeSpan.FromMilliseconds(100); var dateFormat = "yyyy-MM-dd HH:mm:ss.fff"; var difference = (now - result.CheckTimeUtc) - result.ResponseTime; Assert.True(difference.Duration() < delta, string.Format("Expected CheckTimeUtc being {0} ~ {1}ms, got: {2}", (now - result.ResponseTime).ToString(dateFormat), delta.TotalMilliseconds, result.CheckTimeUtc.ToString(dateFormat))); }
public async Task CheckHealth(IHealthSampler sampler, CancellationToken cancellationToken) { Health = await sampler.CheckHealth(this, cancellationToken); }
private void AssertResponseTime(EndpointHealth result, TimeSpan expectedTime) { var delta = TimeSpan.FromMilliseconds(100); var difference = result.ResponseTime - expectedTime; Assert.True(difference.Duration() < delta, string.Format("Expected ResponseTime being {0} ~ {1}ms, got: {2}", expectedTime, delta.TotalMilliseconds, result.ResponseTime)); }
public EndpointHealthUpdate(Guid endpointId, EndpointHealth health) { EndpointId = endpointId; Health = health; }
public void GetEndpoint_should_return_endpoint_information_with_details(EndpointStatus status) { Guid id = Guid.NewGuid(); var healthSampler = new Mock<IHealthSampler>(); var endpoint = new Endpoint(id, MonitorMock.GetMock("monitor").Object, "address", "name", "group"); var token = new CancellationToken(); var endpointHealth = new EndpointHealth(DateTime.UtcNow, TimeSpan.FromSeconds(1), status, new Dictionary<string, string> { { "a", "b" }, { "c", "d" } }); healthSampler.Setup(s => s.CheckHealth(endpoint, token)).Returns(Task.FromResult(endpointHealth)); endpoint.CheckHealth(healthSampler.Object, token).Wait(); _endpointRegistry.Setup(r => r.GetById(id)).Returns(endpoint); var result = _controller.GetEndpoint(id) as OkNegotiatedContentResult<EndpointDetails>; Assert.NotNull(result); AssertEndpoint(endpoint, result.Content); Assert.Equal(status, result.Content.Status); Assert.Equal(endpointHealth.CheckTimeUtc, result.Content.LastCheckUtc); Assert.Equal(endpointHealth.ResponseTime, result.Content.LastResponseTime); Assert.Equal(endpointHealth.Details, result.Content.Details); }