@Override
    public Health health() {
        Map<String, Health> healths = rateLimiterRegistry.getAllRateLimiters().stream()
            .filter(this::isRegisterHealthIndicator)
            .collect(Collectors.toMap(RateLimiter::getName, this::mapRateLimiterHealth));

        Status status = statusAggregator.getAggregateStatus(healths.values().stream().map(Health::getStatus).collect(Collectors.toSet()));
        return Health.status(status).withDetails(healths).build();
    }
@Test
    public void healthIndicatorMaxImpactCanBeOverridden() throws Exception {
        // given
        RateLimiterConfig config = mock(RateLimiterConfig.class);
        AtomicRateLimiter.AtomicRateLimiterMetrics metrics = mock(AtomicRateLimiter.AtomicRateLimiterMetrics.class);
        AtomicRateLimiter rateLimiter = mock(AtomicRateLimiter.class);
        RateLimiterRegistry rateLimiterRegistry = mock(RateLimiterRegistry.class);
        io.github.resilience4j.common.ratelimiter.configuration.CommonRateLimiterConfigurationProperties.InstanceProperties instanceProperties =
                mock(io.github.resilience4j.common.ratelimiter.configuration.CommonRateLimiterConfigurationProperties.InstanceProperties.class);
        RateLimiterConfigurationProperties rateLimiterProperties = mock(RateLimiterConfigurationProperties.class);

        //when
        when(rateLimiter.getRateLimiterConfig()).thenReturn(config);
        when(rateLimiter.getName()).thenReturn("test");
        when(rateLimiterProperties.findRateLimiterProperties("test")).thenReturn(Optional.of(instanceProperties));
        when(instanceProperties.getRegisterHealthIndicator()).thenReturn(true);

        boolean allowHealthIndicatorToFail = false; // do not allow health indicator to fail
        when(instanceProperties.getAllowHealthIndicatorToFail()).thenReturn(allowHealthIndicatorToFail);
        when(rateLimiter.getMetrics()).thenReturn(metrics);
        when(rateLimiter.getDetailedMetrics()).thenReturn(metrics);
        when(rateLimiterRegistry.getAllRateLimiters()).thenReturn(Set.of(rateLimiter));

        when(config.getTimeoutDuration()).thenReturn(Duration.ofNanos(30L));

        when(metrics.getAvailablePermissions())
                .thenReturn(-2);
        when(metrics.getNumberOfWaitingThreads())
                .thenReturn(2);
        when(metrics.getNanosToWait())
                .thenReturn(40L);

        // then
        RateLimitersHealthIndicator healthIndicator =
                new RateLimitersHealthIndicator(rateLimiterRegistry, rateLimiterProperties, new SimpleStatusAggregator());

        Health health = healthIndicator.health();
        then(health.getStatus()).isEqualTo(Status.UNKNOWN);
        then(((Health) health.getDetails().get("test")).getStatus()).isEqualTo(new Status("RATE_LIMITED"));

        then(health.getDetails().get("test")).isInstanceOf(Health.class);
        then(((Health) health.getDetails().get("test")).getDetails())
                .contains(
                        entry("availablePermissions", -2),
                        entry("numberOfWaitingThreads", 2)
                );
    }