/// <summary>
        ///     Registers a health check on the process confirming that the current amount of physical memory is below the
        ///     threshold.
        /// </summary>
        /// <param name="registry">The health check registry where the health check is registered.</param>
        /// <param name="name">The name of the health check.</param>
        /// <param name="thresholdBytes">The physical memory threshold in bytes.</param>
        /// <returns>The health check registry instance</returns>
        public static IHealthCheckRegistry AddProcessPhysicalMemoryCheck(this IHealthCheckRegistry registry, string name, long thresholdBytes)
        {
            registry.Register(
                name,
                () =>
            {
                var currentSize = Process.GetCurrentProcess().WorkingSet64;
                return(new ValueTask <HealthCheckResult>(
                           currentSize <= thresholdBytes
                            ? HealthCheckResult.Healthy($"OK. {thresholdBytes} bytes")
                            : HealthCheckResult.Unhealthy($"FAILED. {currentSize} > {thresholdBytes}")));
            });

            return(registry);
        }
        public static IHealthCheckRegistry AddPingCheck(
            this IHealthCheckRegistry registry,
            string name,
            string host,
            TimeSpan timeout)
        {
            registry.Register(
                name,
                async() =>
            {
                var ping   = new Ping();
                var result = await ping.SendPingAsync(host, (int)timeout.TotalMilliseconds).ConfigureAwait(false);

                return(result.Status == IPStatus.Success
                        ? HealthCheckResult.Healthy($"OK. {host}")
                        : HealthCheckResult.Unhealthy($"FAILED. {host} ping result was {result.Status}"));
            });

            return(registry);
        }
        public static IHealthCheckRegistry AddHttpGetCheck(
            this IHealthCheckRegistry registry,
            string name,
            Uri uri,
            TimeSpan timeout)
        {
            registry.Register(
                name,
                async cancellationToken =>
            {
                using (var tokenWithTimeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
                {
                    tokenWithTimeout.CancelAfter(timeout);

                    var response = await HttpClient.GetAsync(uri, tokenWithTimeout.Token).ConfigureAwait(false);

                    return(response.IsSuccessStatusCode
                            ? HealthCheckResult.Healthy($"OK. {uri}")
                            : HealthCheckResult.Unhealthy($"FAILED. {uri} status code was {response.StatusCode}"));
                }
            });

            return(registry);
        }
예제 #4
0
 /// <summary>
 ///     Initializes a new instance of the <see cref="DefaultHealthProvider" /> class.
 /// </summary>
 /// <param name="logger">The logger.</param>
 /// <param name="healthCheckRegistry">The health check registry.</param>
 public DefaultHealthProvider(ILogger <DefaultHealthProvider> logger, IHealthCheckRegistry healthCheckRegistry)
 {
     _logger = logger;
     _healthCheckRegistry = healthCheckRegistry;
 }
예제 #5
0
#pragma warning disable SA1008, SA1009
        internal static ValueTask <HealthCheckResult> PerformCheck <T>(
            this IHealthCheckRegistry registry,
            Func <T, (string message, bool result)> passing,