protected void SetupServices( IServiceCollection services, HealthEndpointsOptions healthMiddlewareCoreChecksOptions, IEnumerable <HealthCheckResult> healthChecks = null) { services.AddOptions(); services.AddLogging(); // TODO: scan for healthchecks // var startupAssemblyName = typeof(TestStartup).Assembly.GetName().Name; var builder = new HealthBuilder() .Configuration.Configure(options => options.Enabled = true) .OutputHealth.AsPlainText() .OutputHealth.AsJson(); var checks = healthChecks?.ToList() ?? new List <HealthCheckResult>(); for (var i = 0; i < checks.Count; i++) { var check = checks[i]; builder.HealthChecks.AddCheck("Check" + i, () => new ValueTask <HealthCheckResult>(check)); } services.AddHealth(builder) .AddHealthEndpoints( options => { options.HealthEndpointEnabled = healthMiddlewareCoreChecksOptions.HealthEndpointEnabled; options.PingEndpointEnabled = healthMiddlewareCoreChecksOptions.PingEndpointEnabled; options.Timeout = healthMiddlewareCoreChecksOptions.Timeout; }); }
public void Should_throw_when_task_is_cancelled() { // Arrange const string name = "custom with cancellation token"; // Act var builder = new HealthBuilder().HealthChecks.AddCheck( name, async token => { await Task.Delay(2000, token); return(HealthCheckResult.Healthy()); }); var tokenSource = new CancellationTokenSource(); tokenSource.CancelAfter(200); var check = builder.Build().Checks.Single(); // Assert Action action = () => { var result = check.ExecuteAsync(tokenSource.Token).GetAwaiter().GetResult(); result.Check.Status.Should().Be(HealthCheckStatus.Unhealthy); }; action.ShouldThrow <OperationCanceledException>(); }
private IHealthRoot ConfigureHealth() { var healthBuilder = new HealthBuilder(); healthBuilder.HealthChecks.AddCheck(new SampleHealthCheck()); return(healthBuilder.Build()); }
private static void Init() { var configurationBuilder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json"); Configuration = configurationBuilder.Build(); var services = new ServiceCollection(); var unused = new HealthBuilder() .Configuration.ReadFrom(Configuration) .OutputHealth.AsPlainText() .OutputHealth.AsJson() .HealthChecks.AddCheck("inline-check", () => new ValueTask <HealthCheckResult>(HealthCheckResult.Healthy())) .HealthChecks.RegisterFromAssembly(services) .BuildAndAddTo(services); // BuildAndAddTo will add services to the IServiceCollection // services.AddHealth(health); services.AddLogging(builder => { builder.SetMinimumLevel(LogLevel.Trace); builder.AddConsole(); }); ServiceProvider = services.BuildServiceProvider(); }
public async Task Can_apply_ascii_health_formatting() { // Arrange var health = new HealthBuilder() .OutputHealth.AsPlainText() .HealthChecks.AddCheck("test", () => new ValueTask <HealthCheckResult>(HealthCheckResult.Healthy())) .Build(); var serializer = new HealthStatusSerializer(); // Act var healthStatus = await health.HealthCheckRunner.ReadAsync(); using (var sw = new StringWriter()) { using (var writer = new HealthStatusTextWriter(sw)) { serializer.Serialize(writer, healthStatus); } // Assert sw.ToString().Should().Be( "# OVERALL STATUS: Healthy\n--------------------------------------------------------------\n# CHECK: test\n\n MESSAGE = OK\n STATUS = Healthy\n--------------------------------------------------------------\n"); } }
private static async Task Main(string[] args) { var health = new HealthBuilder() .HealthChecks.AddCheck <SampleHealthCheck>() .HealthChecks.AddCheck("Healthy Check", () => new ValueTask <HealthCheckResult>(HealthCheckResult.Healthy())) .HealthChecks.AddCheck("Degraded Check", () => new ValueTask <HealthCheckResult>(HealthCheckResult.Degraded())) .HealthChecks.AddCheck("Unhealthy Check", () => new ValueTask <HealthCheckResult>(HealthCheckResult.Unhealthy())) .HealthChecks.AddProcessPrivateMemorySizeCheck("Private Memory Size", 100) .HealthChecks.AddProcessVirtualMemorySizeCheck("Virtual Memory Size", 200) .HealthChecks.AddProcessPhysicalMemoryCheck("Working Set", 300) .HealthChecks.AddPingCheck("google ping", "google.com", TimeSpan.FromSeconds(10)) .HealthChecks.AddHttpGetCheck("github", new Uri("https://github.com/"), TimeSpan.FromSeconds(10)) .Build(); var healthStatus = await health.HealthCheckRunner.ReadAsync(); using (var stream = new MemoryStream()) { await health.DefaultOutputHealthFormatter.WriteAsync(stream, healthStatus); var result = Encoding.UTF8.GetString(stream.ToArray()); WriteLine(result); } ReadKey(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddMvc(options => { //options.Filters.Add(new ValidationAttribute()); options.Filters.Add(new ExceptionHandlerFilterAttribute(_loggerFactory)); }) .SetCompatibilityVersion(CompatibilityVersion.Version_2_2) .AddFluentValidation(fv => fv.RegisterValidatorsFromAssembly(Assembly.GetExecutingAssembly())); services.AddCors(); ConfigureServicesDI(services); services.AddAutoMapper(); ConfigureServicesVersioning(services); ConfigureServicesSwagger(services); var memoryThreshhold = 800000000; // 800 MB var healthBuilder = new HealthBuilder() // Check that the current amount of physical memory in bytes is below a threshold .HealthChecks.AddProcessPhysicalMemoryCheck("Working Set", memoryThreshhold) // Check connectivity to google with a "ping", passes if the result is `IPStatus.Success` .HealthChecks.AddPingCheck("google ping", "google.com", TimeSpan.FromSeconds(10)) // Check that our SQL Server is still up and running .HealthChecks.AddSqlCheck("Food Truck Database", _configuration.GetConnectionString("FoodTruckConnectionString"), TimeSpan.FromSeconds(10)) .OutputHealth.AsJson() .BuildAndAddTo(services); services.AddHealthEndpoints(); }
public static async Task Main() { long threshold = 1; var metricsBuilder = new MetricsBuilder(); var healthBuilder = new HealthBuilder(); var metrics = metricsBuilder.Report.ToInfluxDb(AppSetting.InfluxDB.Url, AppSetting.InfluxDB.DatabaseName, TimeSpan.FromSeconds(5)) .Report.ToConsole(TimeSpan.FromSeconds(5)) .Build() ; var health = healthBuilder.Configuration .Configure(p => { p.Enabled = true; p.ReportingEnabled = true; }) .Report .ToMetrics(metrics) .HealthChecks.AddProcessPrivateMemorySizeCheck("Private Memory Size", threshold) .HealthChecks.AddProcessVirtualMemorySizeCheck("Virtual Memory Size", threshold) .HealthChecks.AddProcessPhysicalMemoryCheck("Working Set", threshold) .HealthChecks.AddPingCheck("google ping", "google.com", TimeSpan.FromSeconds(10)) .Build(); var counter = new CounterOptions { Name = "my_counter" }; metrics.Measure.Counter.Increment(counter); var scheduler = new AppMetricsTaskScheduler(TimeSpan.FromSeconds(5), async() => { await Task.WhenAll(metrics.ReportRunner.RunAllAsync()); var healthStatus = await health.HealthCheckRunner.ReadAsync(); using (var stream = new MemoryStream()) { await health.DefaultOutputHealthFormatter .WriteAsync(stream, healthStatus); var result = Encoding.UTF8.GetString(stream.ToArray()); Console.WriteLine(result); } foreach (var reporter in health.Reporters) { await reporter.ReportAsync(health.Options, healthStatus); } }); scheduler.Start(); Console.ReadKey(); }
public HealthTestFixture() { var health = new HealthBuilder() .HealthChecks.AddCheck("test", () => new ValueTask <HealthCheckResult>(HealthCheckResult.Healthy())) .Build(); HealthCheckRunner = health.HealthCheckRunner; }
public static IServiceCollection AddHealth(this IServiceCollection services, Action <IHealthBuilder> setupHealth) { var builder = new HealthBuilder(); setupHealth(builder); return(AddHealth(services, builder)); }
public void Options_should_not_be_null_when_configuration_not_used() { // Arrange var builder = new HealthBuilder(); // Act var health = builder.Build(); // Assert health.Options.Should().NotBeNull(); }
public void When_checks_registered_should_not_use_noop_runner() { // Arrange var builder = new HealthBuilder(); // Act var health = builder.HealthChecks.AddCheck("test", () => new ValueTask <HealthCheckResult>(HealthCheckResult.Healthy())).Build(); // Assert health.HealthCheckRunner.Should().NotBeOfType <NoOpHealthCheckRunner>(); }
public void When_no_checks_registered_use_noop_runner() { // Arrange var builder = new HealthBuilder(); // Act var health = builder.OutputHealth.AsPlainText().Build(); // Assert health.HealthCheckRunner.Should().BeOfType <NoOpHealthCheckRunner>(); }
public void Can_use_reporter_of_type() { // Arrange var builder = new HealthBuilder().Report.Using <TestReporter>(); // Act var metrics = builder.Build(); // Assert metrics.Reporters.Should().Contain(reportMetrics => reportMetrics is TestReporter); }
public void At_least_one_formatter_is_required() { // Arrange var builder = new HealthBuilder(); // Act var health = builder.Build(); // Assert health.OutputHealthFormatters.Count.Should().Be(1); health.DefaultOutputHealthFormatter.Should().NotBeNull(); }
public void Default_formatter_should_default_to_text_if_not_configured() { // Arrange var builder = new HealthBuilder(); // Act var health = builder.Build(); // Assert health.DefaultOutputHealthFormatter.Should().NotBeNull(); health.DefaultOutputHealthFormatter.Should().BeOfType <HealthStatusTextOutputFormatter>(); }
public void Cannot_set_null_reporter() { // Arrange Action action = () => { // Act var unused = new HealthBuilder().Report.Using(reporter: null); }; // Assert action.Should().Throw <ArgumentNullException>(); }
public void Can_use_reporter_of_type_and_override_flushinterval() { // Arrange var builder = new HealthBuilder().Report.Using <TestReporter>(reportInterval: TimeSpan.FromDays(1)); // Act var metrics = builder.Build(); var reporter = (metrics.Reporters as HealthReporterCollection)?.GetType <TestReporter>(); // Assert reporter?.ReportInterval.Should().Be(TimeSpan.FromDays(1)); }
public void Cannot_set_null_health_output_formatter() { // Arrange Action action = () => { // Act var unused = new HealthBuilder().OutputHealth.Using(null); }; // Assert action.Should().Throw <ArgumentNullException>(); }
/// <summary> /// Initializes a new instance of the <see cref="IHealthBuilder" /> class with pre-configured defaults. /// </summary> /// <remarks> /// The following defaults are applied to the returned <see cref="IHealthBuilder" />: /// use, JSON and Plain Text health check result formatting. /// </remarks> /// <returns>The initialized <see cref="IHealthBuilder" />.</returns> public static IHealthBuilder CreateDefaultBuilder() { var builder = new HealthBuilder().Configuration.Configure( options => { options.Enabled = true; }) .OutputHealth.AsJson() .OutputHealth.AsPlainText(); return(builder); }
public void Cannot_set_null_health_check() { // Arrange Action action = () => { // Act var unused = new HealthBuilder().HealthChecks.AddCheck(null, () => HealthyResult); }; // Assert action.Should().Throw <ArgumentNullException>(); }
public void Can_register_type_health_checks() { // Arrange var builder = new HealthBuilder(); // Act var health = builder.HealthChecks.AddCheck <SampleHealthCheck>().Build(); // Assert health.Checks.Count().Should().Be(1); health.Checks.Single().Name.Should().Be("SampleHealthCheck"); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.Configure <EndpointsConfig>(Configuration.GetSection("Endpoints")); services.AddSingleton <IBusDataStore, RedisBusDataStore>(); services.AddSingleton <IRabbitMQPersistentConnection>(sp => { var factory = new ConnectionFactory() { HostName = Configuration.GetValue <string>("Endpoints:RabbitMq") }; if (!string.IsNullOrEmpty(Configuration["EventBusUserName"])) { factory.UserName = Configuration["EventBusUserName"]; } if (!string.IsNullOrEmpty(Configuration["EventBusPassword"])) { factory.Password = Configuration["EventBusPassword"]; } var retryCount = 5; if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"])) { retryCount = int.Parse(Configuration["EventBusRetryCount"]); } return(new DefaultRabbitMQPersistentConnection(factory, retryCount)); }); RegisterEventBus(services); var identityServerEndpoint = Configuration.GetValue <string>("Endpoints:IdentityServer"); // Add health checks var healthBuilder = new HealthBuilder() .HealthChecks.AddHttpGetCheck("IdentityServer", new Uri(new Uri(identityServerEndpoint), "/_system/health"), 3, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(2)); services.AddHealth(healthBuilder.Build()); services.TryAddEnumerable(ServiceDescriptor.Singleton <IConfigureOptions <HealthEndpointsHostingOptions>, HealthCheckOptions>()); services.AddMvc(); services.AddAuthentication("Bearer") .AddIdentityServerAuthentication(options => { options.Authority = identityServerEndpoint; options.RequireHttpsMetadata = false; options.ApiName = "resources"; }); }
public void Can_register_instance_health_checks() { // Arrange var builder = new HealthBuilder(); var check = new DatabaseHealthCheck(new Database()); // Act var health = builder.HealthChecks.AddCheck(check).Build(); // Assert health.Checks.Count().Should().Be(1); health.Checks.Single().Name.Should().Be("DatabaseCheck"); }
public void Can_register_health_check_without_cancellation_token() { // Arrange const string check = "check"; var builder = new HealthBuilder(); // Act var health = builder.HealthChecks.AddCheck(check, () => new ValueTask <HealthCheckResult>(HealthCheckResult.Degraded())).Build(); // Assert health.Checks.Count().Should().Be(1); health.Checks.First(c => c.Name == check).Should().NotBeNull(); }
public void Can_set_options_with_instance() { // Arrange var options = new HealthOptions { Enabled = true }; // Act var health = new HealthBuilder().Configuration.Configure(options).Build(); // Assert health.Options.Enabled.Should().BeTrue(); }
public void Can_bind_metrics_options_from_configuration() { // Arrange var builder = new HealthBuilder(); var configuration = new ConfigurationBuilder().AddJsonFile("JsonFIles/HealthOptions.json").Build(); // Act builder.Configuration.ReadFrom(configuration); var health = builder.Build(); // Assert health.Options.Enabled.Should().BeFalse(); }
public void Should_set_health_output_formatters_when_selected_via_type() { // Arrange var builder = new HealthBuilder() .OutputHealth.Using <HealthStatusTextOutputFormatter>() .OutputHealth.Using <HealthStatusJsonOutputFormatter>(); // Act var health = builder.Build(); // Assert health.OutputHealthFormatters.Count.Should().Be(2); }
public void Default_health_output_formatter_should_be_first_formatter_selected_via_type() { // Arrange var builder = new HealthBuilder() .OutputHealth.Using <HealthStatusJsonOutputFormatter>() .OutputHealth.Using <HealthStatusTextOutputFormatter>(); // Act var health = builder.Build(); // Assert health.DefaultOutputHealthFormatter.Should().BeOfType <HealthStatusJsonOutputFormatter>(); }
public void Should_only_add_a_single_formatter_of_the_same_type() { // Arrange var builder = new HealthBuilder() .OutputHealth.Using <HealthStatusTextOutputFormatter>() .OutputHealth.Using <HealthStatusTextOutputFormatter>(); // Act var health = builder.Build(); // Assert health.OutputHealthFormatters.Count.Should().Be(1); health.DefaultOutputHealthFormatter.Should().NotBeNull(); }