Java Health类代码示例

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Override
public Health health() {
	try {
		URL url =
			new URL("http://greglturnquist.com/learning-spring-boot");
		HttpURLConnection conn =
			(HttpURLConnection) url.openConnection();
		int statusCode = conn.getResponseCode();
		if (statusCode >= 200 && statusCode < 300) {
			return Health.up().build();
		} else {
			return Health.down()
				.withDetail("HTTP Status Code", statusCode)
				.build();
		}
	} catch (IOException e) {
		return Health.down(e).build();
	}
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Override
public Health health() {
	String hostname="unknown";
	
	try {
		hostname = InetAddress.getLocalHost().getHostName();
	} catch (UnknownHostException ex) {
		log.warn("Failed to get hostname.",ex);
	}
	
	return Health.up()
			.withDetail("hostname", hostname)
			.withDetail("localTime", LocalDateTime.now())
			.withDetail("date", new Date()) // uses spring.jackson.date-format
			.build();
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@RequestMapping(method = RequestMethod.GET, produces = {
        ActuatorMediaTypes.APPLICATION_ACTUATOR_V1_JSON_VALUE,
        MediaType.APPLICATION_JSON_VALUE})
@ResponseBody
public Object invoke(HttpServletRequest request) {
    if (!getDelegate().isEnabled()) {
        // Shouldn't happen because the request mapping should not be registered
        return getDisabledResponse();
    }
    Health health = getDelegate().invoke();
    HttpStatus status = this.statusMapping.get(health.getStatus().getCode());
    if (status != null) {
        return new ResponseEntity<>(health, status);
    }
    return health;
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Test
public void downWithExceptionHandling() throws Exception {

    HealthAggregator healthAggregator = mock(HealthAggregator.class);
    ApplicationAliveIndicator healthIndicator = mock(ApplicationAliveIndicator.class);
    when(healthIndicator.health()).thenThrow(new RuntimeException("fooException"));
    Map<String, ApplicationAliveIndicator> healthIndicators = new LinkedHashMap<>();
    healthIndicators.put("foo", healthIndicator);

    when(applicationContext.getBeansOfType(ApplicationAliveIndicator.class)).thenReturn(healthIndicators);


    extendedHealthEndpoint = new AliveHealthEndpoint("healthIndicatorfoo", healthAggregator);
    extendedHealthEndpoint.setApplicationContext(applicationContext);

    this.extendedHealthMvcEndpoint = new ExtendedHealthMvcEndpoint(this.extendedHealthEndpoint);

    ResponseEntity<Health> result = (ResponseEntity<Health>) this.extendedHealthMvcEndpoint.invoke(null);

    Map<String, Object> expectedHealthDetails = new LinkedHashMap<>();
    expectedHealthDetails.put("error", "java.lang.RuntimeException: fooException");
    assertThat(result.getBody().getDetails(), is(expectedHealthDetails));
    assertThat(result.getStatusCode(), is(HttpStatus.SERVICE_UNAVAILABLE));
    assertThat(result.getBody().getStatus(), is(Status.DOWN));
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
private void appendProviderDetails(Health.Builder builder, String name, Processor processor) {
    final Health.Builder sub = new Health.Builder(Status.UP);
    if (processor != null) {
        sub
                .withDetail("key", processor.getKey())
                .withDetail("name", processor.getName())
                .withDetail("class", processor.getClass().getName())
                ;
    } else {
        sub.outOfService();
        if (requiredProvidersHealthCheckProperties.isFailOnMissing() &&
                requiredProvidersHealthCheckProperties.getFailIfMissing().getOrDefault(name, true)) {
            builder.down();
        }
    }
    builder.withDetail(name, sub.build());
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
    log.debug("Initializing JavaMail health indicator");
    try {
        javaMailSender.getSession().getTransport().connect(javaMailSender.getHost(),
                javaMailSender.getPort(),
                javaMailSender.getUsername(),
                javaMailSender.getPassword());

        builder.up();

    } catch (MessagingException e) {
        log.debug("Cannot connect to e-mail server. Error: {}", e.getMessage());
        builder.down(e);
    }
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
    try {
        GetServerInfoResponse serverInfo = client.getServerInfo();
        List<App> apps = client.getApps().getApps();
        builder.up()
                .withDetail("services", apps)
                .withDetail("name", serverInfo.getName())
                .withDetail("leader", serverInfo.getLeader())
                .withDetail("http_port", serverInfo.getHttp_config().getHttp_port())
                .withDetail("https_port", serverInfo.getHttp_config().getHttps_port())
                .withDetail("hostname", serverInfo.getMarathon_config().getHostname())
                .withDetail("local_port_min", serverInfo.getMarathon_config().getLocal_port_min())
                .withDetail("local_port_max", serverInfo.getMarathon_config().getLocal_port_max());
    }
    catch (Exception e) {
        builder.down(e);
    }
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
    if (camelContext == null) {
        builder.unknown();
    } else {
        builder.withDetail("version", camelContext.getVersion());
        builder.withDetail("contextStatus", camelContext.getStatus().name());
        if (camelContext.getStatus().isStarted()) {
            builder.up();
        } else if (camelContext.getStatus().isStopped()) {
            builder.down();
        } else {
            builder.unknown();
        }
    }
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
  boolean isDown = false;
  for (HealthTrackable provider : providers) {
    builder.withDetail(provider.getClass().getSimpleName(), provider.getHealthTracker().getHealthView());
    isDown = isDown || !provider.getHealthTracker().isProviderHealthy();
  }

  if (isDown) {
    if (previousHealthCheckIsUp.getAndSet(false)) {
      log.warn("Server is now UNHEALTHY");
    }
    builder.down();
  } else {
    if (!previousHealthCheckIsUp.getAndSet(true)) {
      log.info("Server is now HEALTHY. Hooray!");
    }
    builder.up();
  }
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Test
public void testDoHealthCheckSingleQueueCheckMetricException() throws Exception
{
    Queue queue = generateQueue("test");
    healthIndicator.addQueueCheck(queue, 10000, 2);

    propertiesManager.request(queue);
    PowerMock.expectLastCall().andThrow(new RuntimeException());

    PowerMock.replayAll();
    Builder builder = new Builder(Status.OUT_OF_SERVICE);
    healthIndicator.doHealthCheck(builder);
    PowerMock.verifyAll();

    Health health = builder.build();
    Assert.assertEquals(Status.DOWN, health.getStatus());
    Assert.assertNull(health.getDetails().get("test"));
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Test
public void newValueIsReturnedOnceTtlExpires() throws InterruptedException {
	given(this.endpoint.getTimeToLive()).willReturn(50L);
	given(this.endpoint.isSensitive()).willReturn(false);
	given(this.endpoint.invoke())
			.willReturn(new Health.Builder().up().withDetail("foo", "bar").build());
	Object result = this.mvc.invoke(null);
	assertThat(result instanceof Health).isTrue();
	assertThat(((Health) result).getStatus() == Status.UP).isTrue();
	Thread.sleep(100);
	given(this.endpoint.invoke()).willReturn(new Health.Builder().down().build());
	result = this.mvc.invoke(null);
	@SuppressWarnings("unchecked")
	Health health = ((ResponseEntity<Health>) result).getBody();
	assertThat(health.getStatus() == Status.DOWN).isTrue();
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
    try {
        Pod current = utils.currentPod().get();
        if (current != null) {
            builder.up()
                    .withDetail("inside", true)
                    .withDetail("namespace", current.getMetadata().getNamespace())
                    .withDetail("podName", current.getMetadata().getName())
                    .withDetail("podIp", current.getStatus().getPodIP())
                    .withDetail("serviceAccount", current.getSpec().getServiceAccountName())
                    .withDetail("nodeName", current.getSpec().getNodeName())
                    .withDetail("hostIp", current.getStatus().getHostIP());
        } else {
            builder.up()
                    .withDetail("inside", false);
        }
    } catch (Exception e) {
        builder.down(e);
    }
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Override
public Health health() {

	try {

		VaultHealth vaultHealthResponse = vaultOperations.opsForSys().health();

		Builder healthBuilder = getHealthBuilder(vaultHealthResponse);

		if (StringUtils.hasText(vaultHealthResponse.getVersion())) {
			healthBuilder = healthBuilder.withDetail("version",
					vaultHealthResponse.getVersion());
		}

		return healthBuilder.build();
	}
	catch (Exception e) {
		return Health.down(e).build();
	}
}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
private Builder getHealthBuilder(VaultHealth vaultHealthResponse) {

		if (!vaultHealthResponse.isInitialized()) {
			return Health.down().withDetail("state", "Vault uninitialized");
		}

		if (vaultHealthResponse.isSealed()) {
			return Health.down().withDetail("state", "Vault sealed");
		}

		if (vaultHealthResponse.isStandby()) {
			return Health.up().withDetail("state", "Vault in standby");
		}

		return Health.up();
	}
 

import org.springframework.boot.actuate.health.Health; //导入依赖的package包/类
@Bean
public HealthIndicator taskHealthIndicator() {
    return new AbstractHealthIndicator() {
        @Override
        protected void doHealthCheck(Health.Builder builder) throws Exception {
            if (correctNumberOfInstances()) {
                builder.up();
            } else {
                builder.down();
            }
            builder.withDetail("mesos.resources.count", instanceCount.getCount());
            builder.withDetail("instances", stateRepository.allTaskInfos().size());

            for (Protos.TaskState taskState : Protos.TaskState.values()) {
                Map<String, Protos.TaskStatus> state = getTasksForState(taskState);
                builder.withDetail(taskState.name(), state.size());
            }
        }
    };
}