io.micronaut.health.HealthStatus Java Examples

/**
 * Get the health result of the streams.  Will attempt to interrogate
 * details of each stream as well.  The application.id will be used
 * for each configured stream as the primary health check name.
 *
 * @return Health Result Aggregate
 */

@Override
public Publisher<HealthResult> getResult() {
    Flowable<HealthResult> kafkaStreamHealth = Flowable.fromIterable(this.kafkaStreamsFactory.getStreams().keySet())
            .map(kafkaStreams -> Pair.of(getApplicationId(kafkaStreams), kafkaStreams))
            .flatMap(pair -> Flowable.just(pair)
                    .filter(p -> p.getValue().state().isRunningOrRebalancing())
                    .map(p -> HealthResult.builder(p.getKey(), HealthStatus.UP)
                            .details(buildDetails(p.getValue())))
                    .defaultIfEmpty(HealthResult.builder(pair.getKey(), HealthStatus.DOWN)
                            .details(buildDownDetails(pair.getValue().state())))
                    .onErrorReturn(e -> HealthResult.builder(pair.getKey(), HealthStatus.DOWN)
                            .details(buildDownDetails(e.getMessage(), pair.getValue().state()))))
            .map(HealthResult.Builder::build);
    return healthAggregator.aggregate(NAME, kafkaStreamHealth);
}
 

@Override
public Publisher<HealthResult> getResult() {
    return client.query(QUERY).rxExecute().map(rows -> {
        HealthResult.Builder status = HealthResult.builder(NAME, HealthStatus.UP);
        Row row = rows.iterator().next();
        status.details(Collections.singletonMap("version", row.getString(0)));
        return status.build();
    }).onErrorReturn(this::buildErrorResult).toFlowable();
}
 

@Override
public Publisher<HealthResult> getResult() {
    return Flowable.fromFuture(client.sendQuery(QUERY))
            .map(queryResult -> {
                Map<String, String> error = new HashMap<>(1);
                error.put("version", String.valueOf(queryResult.getRows().get(0).get(0)));
                return HealthResult.builder(NAME, HealthStatus.UP).details(error).build();
            })
            .onErrorReturn(error -> HealthResult.builder(NAME, HealthStatus.DOWN).exception(error).build());
}
 

@Override
public Publisher<HealthResult> getResult() {
    return client.query(QUERY).rxExecute().map(rows -> {
        HealthResult.Builder status = HealthResult.builder(NAME, HealthStatus.UP);
        Row row = rows.iterator().next();
        status.details(Collections.singletonMap("version", row.getString(0)));
        return status.build();
    }).onErrorReturn(this::buildErrorResult).toFlowable();
}
 

/**
 * If custom health check is enabled, this sends a heartbeat to it.
 * In most cases aws monitoring works off polling an application's endpoint
 * @param instance The instance of the service
 * @param status   The {@link HealthStatus}
 */
@Override
protected void pulsate(ServiceInstance instance, HealthStatus status) {
    // this only work if you create a health status check when you register it
    // we can't really pulsate anywhere because amazon health checks work inverse from this UNLESS you have a custom health check
    Optional<String> opt = instance.getInstanceId();
    if (!opt.isPresent()) {
        // try the metadata
        if (instance.getMetadata().contains("instanceId")) {
            opt = Optional.of(instance.getMetadata().asMap().get("instanceId"));
        } else {
            if (LOG.isErrorEnabled()) {
                LOG.error("Cannot determine the instance ID. Are you sure you are running on AWS EC2?");
            }
        }
    }

    opt.ifPresent(instanceId -> {
        if (discoveryService != null && discoveryService.getHealthCheckCustomConfig() != null) {
            CustomHealthStatus customHealthStatus = CustomHealthStatus.UNHEALTHY;

            if (status.getOperational().isPresent()) {
                customHealthStatus = CustomHealthStatus.HEALTHY;
            }

            UpdateInstanceCustomHealthStatusRequest updateInstanceCustomHealthStatusRequest = new UpdateInstanceCustomHealthStatusRequest()
                                                                                                        .withInstanceId(instanceId)
                                                                                                        .withServiceId(route53AutoRegistrationConfiguration.getAwsServiceId())
                                                                                                        .withStatus(customHealthStatus);
            getDiscoveryClient().updateInstanceCustomHealthStatus(
                    updateInstanceCustomHealthStatusRequest);
        }

        if (status.getOperational().isPresent() && !status.getOperational().get()) {
            getDiscoveryClient().deregisterInstance(new DeregisterInstanceRequest().withInstanceId(instanceId).withServiceId(route53AutoRegistrationConfiguration.getAwsServiceId()));
            LOG.info("Health status is non operational, instance id " + instanceId + " was de-registered from the discovery service.");
        }

    });

}
 

/**
 * Gets the current instance health status.
 * @return status
 */
@Override
public HealthStatus getHealthStatus() {
    return healthStatus;
}
 

private HealthResult buildErrorResult(Throwable throwable) {
    return HealthResult.builder(NAME, HealthStatus.DOWN).exception(throwable).build();
}
 

private HealthResult buildErrorResult(Throwable throwable) {
    return HealthResult.builder(NAME, HealthStatus.DOWN).exception(throwable).build();
}
 

@Override
public Flowable<HealthResult> getResult() {
    DescribeClusterResult result = adminClient.describeCluster(
            new DescribeClusterOptions().timeoutMs(
                    (int) defaultConfiguration.getHealthTimeout().toMillis()
            )
    );

    Flowable<String> clusterId = Flowable.fromFuture(result.clusterId());
    Flowable<Collection<Node>> nodes = Flowable.fromFuture(result.nodes());
    Flowable<Node> controller = Flowable.fromFuture(result.controller());

    return controller.switchMap(node -> {
        String brokerId = node.idString();
        ConfigResource configResource = new ConfigResource(ConfigResource.Type.BROKER, brokerId);
        DescribeConfigsResult configResult = adminClient.describeConfigs(Collections.singletonList(configResource));
        Flowable<Map<ConfigResource, Config>> configs = Flowable.fromFuture(configResult.all());
        return configs.switchMap(resources -> {
            Config config = resources.get(configResource);
            ConfigEntry ce = config.get(REPLICATION_PROPERTY);
            int replicationFactor = Integer.parseInt(ce.value());
            return nodes.switchMap(nodeList -> clusterId.map(clusterIdString -> {
                int nodeCount = nodeList.size();
                HealthResult.Builder builder;
                if (nodeCount >= replicationFactor) {
                    builder = HealthResult.builder(ID, HealthStatus.UP);
                } else {
                    builder = HealthResult.builder(ID, HealthStatus.DOWN);
                }
                return builder
                        .details(CollectionUtils.mapOf(
                                "brokerId", brokerId,
                                "clusterId", clusterIdString,
                                "nodes", nodeCount
                        )).build();
            }));
        });
    }).onErrorReturn(throwable ->
            HealthResult.builder(ID, HealthStatus.DOWN)
                    .exception(throwable).build()
    );
}