11 | * {@code
12 | * @Produces
13 | * @ApplicationScoped
14 | * @Liveness
15 | * HealthCheck check1() {
16 | * return new HeapMemoryHealthCheck();
17 | * }
18 | * }
19 | *
20 | */
21 | public class HeapMemoryHealthCheck extends AbstractHeapMemoryHealthCheck {
22 |
23 | public HeapMemoryHealthCheck() {
24 | super();
25 | }
26 |
27 | public HeapMemoryHealthCheck(double maxPercentage) {
28 | super(maxPercentage);
29 | }
30 |
31 | @Override
32 | String name() {
33 | return "heap-memory";
34 | }
35 |
36 | @Override
37 | public HealthCheckResponse call() {
38 | return getHealthCheckResponse(MemoryMXBean::getHeapMemoryUsage);
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/provided-checks/src/main/java/io/smallrye/health/checks/NonHeapMemoryHealthCheck.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health.checks;
2 |
3 | import java.lang.management.MemoryMXBean;
4 |
5 | import org.eclipse.microprofile.health.HealthCheckResponse;
6 |
7 | /**
8 | * Health check implementation that is checking memory usage against available memory
9 | *
10 | *
11 | * {@code
12 | * @Produces
13 | * @ApplicationScoped
14 | * @Liveness
15 | * HealthCheck check1() {
16 | * return new NonHeapMemoryHealthCheck();
17 | * }
18 | * }
19 | *
20 | */
21 | public class NonHeapMemoryHealthCheck extends AbstractHeapMemoryHealthCheck {
22 |
23 | public NonHeapMemoryHealthCheck() {
24 | super();
25 | }
26 |
27 | public NonHeapMemoryHealthCheck(double maxPercentage) {
28 | super(maxPercentage);
29 | }
30 |
31 | @Override
32 | String name() {
33 | return "non-heap-memory";
34 | }
35 |
36 | @Override
37 | public HealthCheckResponse call() {
38 | return getHealthCheckResponse(MemoryMXBean::getNonHeapMemoryUsage);
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/testsuite/tck/src/main/java/io/smallrye/health/SmallRyeHealthServlet.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health;
2 |
3 | import java.io.IOException;
4 |
5 | import jakarta.inject.Inject;
6 | import jakarta.servlet.annotation.WebServlet;
7 | import jakarta.servlet.http.HttpServlet;
8 | import jakarta.servlet.http.HttpServletRequest;
9 | import jakarta.servlet.http.HttpServletResponse;
10 |
11 | @SuppressWarnings("serial")
12 | @WebServlet(name = "SmallRyeHealthServlet", urlPatterns = "/health")
13 | public class SmallRyeHealthServlet extends HttpServlet {
14 |
15 | @Override
16 | protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
17 |
18 | SmallRyeHealth health = reporter.getHealth();
19 | if (health.isDown()) {
20 | resp.setStatus(503);
21 | }
22 | try {
23 | reporter.reportHealth(resp.getOutputStream(), health);
24 | } catch (IOException ioe) {
25 | HealthLogging.logger.error(ioe);
26 | resp.setStatus(500);
27 | }
28 | }
29 |
30 | @Inject
31 | private SmallRyeHealthReporter reporter;
32 | }
33 |
--------------------------------------------------------------------------------
/implementation/src/test/java/io/smallrye/health/HealthCheckResponseProviderTest.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health;
2 |
3 | import java.util.Map;
4 |
5 | import org.eclipse.microprofile.health.HealthCheckResponse;
6 | import org.eclipse.microprofile.health.HealthCheckResponse.Status;
7 | import org.junit.jupiter.api.Assertions;
8 | import org.junit.jupiter.api.Test;
9 |
10 | public class HealthCheckResponseProviderTest {
11 |
12 | @Test
13 | public void testProvider() {
14 |
15 | HealthCheckResponse healthStatus = HealthCheckResponse.named("test")
16 | .up()
17 | .withData("a", "b")
18 | .withData("c", "d")
19 | .build();
20 |
21 | Assertions.assertEquals("test", healthStatus.getName());
22 | Assertions.assertSame(Status.UP, healthStatus.getStatus());
23 | Map
17 | * public void observeLiveness(@Observes @Liveness SmallRyeHealthStatusChangeEvent event) {
18 | * ...
19 | * }
20 | *
21 | */
22 | @Experimental("Health change events")
23 | public record SmallRyeHealthStatusChangeEvent(Instant timestamp, HealthType healthType, SmallRyeHealth health) {
24 |
25 | public SmallRyeHealthStatusChangeEvent(SmallRyeHealth health) {
26 | this(null, health);
27 | }
28 |
29 | public SmallRyeHealthStatusChangeEvent(HealthType healthType, SmallRyeHealth health) {
30 | this(Instant.now(), healthType, health);
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/testsuite/tck/src/test/java/io/smallrye/health/SmallRyeHealthExtension.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017 Red Hat, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package io.smallrye.health;
18 |
19 | import org.jboss.arquillian.container.test.spi.client.deployment.ApplicationArchiveProcessor;
20 | import org.jboss.arquillian.core.spi.LoadableExtension;
21 |
22 | public class SmallRyeHealthExtension implements LoadableExtension {
23 | @Override
24 | public void register(ExtensionBuilder builder) {
25 | builder.service(ApplicationArchiveProcessor.class, SmallRyeHealthArchiveProcessor.class);
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/testsuite/experimental/src/test/java/io/smallrye/health/SmallRyeHealthExtension.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017 Red Hat, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package io.smallrye.health;
18 |
19 | import org.jboss.arquillian.container.test.spi.client.deployment.ApplicationArchiveProcessor;
20 | import org.jboss.arquillian.core.spi.LoadableExtension;
21 |
22 | public class SmallRyeHealthExtension implements LoadableExtension {
23 | @Override
24 | public void register(ExtensionBuilder builder) {
25 | builder.service(ApplicationArchiveProcessor.class, SmallRyeHealthArchiveProcessor.class);
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/implementation/src/main/java/io/smallrye/health/HealthLogging.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health;
2 |
3 | import java.lang.invoke.MethodHandles;
4 |
5 | import org.jboss.logging.BasicLogger;
6 | import org.jboss.logging.Logger;
7 | import org.jboss.logging.annotations.Cause;
8 | import org.jboss.logging.annotations.LogMessage;
9 | import org.jboss.logging.annotations.Message;
10 | import org.jboss.logging.annotations.MessageLogger;
11 |
12 | @MessageLogger(projectCode = "SRHCK", length = 5)
13 | interface HealthLogging extends BasicLogger {
14 | HealthLogging logger = Logger.getMessageLogger(MethodHandles.lookup(), HealthLogging.class,
15 | HealthLogging.class.getPackage().getName());
16 |
17 | @LogMessage(level = Logger.Level.ERROR)
18 | @Message(id = 1000, value = "Error processing Health Checks")
19 | void healthCheckError(@Cause Throwable throwable);
20 |
21 | @LogMessage(level = Logger.Level.INFO)
22 | @Message(id = 1001, value = "Reporting health down status: %s")
23 | void healthDownStatus(String cause);
24 |
25 | @LogMessage(level = Logger.Level.ERROR)
26 | @Message(id = 1002, value = "Health change observer error")
27 | void healthChangeObserverError(@Cause Throwable throwable);
28 | }
29 |
--------------------------------------------------------------------------------
/doc/modules/ROOT/pages/wellness.adoc:
--------------------------------------------------------------------------------
1 | [[wellness]]
2 | = Wellness
3 |
4 | The wellness is another health groups besides the liveness and readiness that can be standardized
5 | as a group of health checks that don't belong to either liveness (application restart) or
6 | readiness (traffic discards) but have a value for any post processing automatic or manual
7 | health monitoring.
8 |
9 | == The @Wellness annotation
10 |
11 | You can use the `@Wellness` annotation in a similar manner as `@Readiness` or `@Liveness`:
12 |
13 | [source,java]
14 | ----
15 | @Wellness <1>
16 | @ApplicationScoped
17 | public class WellnessCheck implements HealthCheck {
18 | @Override
19 | public HealthCheckResponse call() {
20 | return HealthCheckResponse.up("wellness-check");
21 | }
22 | }
23 | ----
24 | <1> The `@Wellness` qualifier
25 |
26 | == Accessing the wellness checks
27 |
28 | The wellness checks are exposed under the `/health/well` endpoint. They are also available
29 | at grouped `/health` endpoint together with all other health checks (liveness, readiness, and
30 | health groups).
31 |
32 | == References
33 |
34 | * https://github.com/smallrye/smallrye-health/blob/main/api/src/main/java/io/smallrye/health/api/Wellness.java[`Wellness`]
35 |
--------------------------------------------------------------------------------
/provided-checks/src/main/java/io/smallrye/health/checks/HealthChecksLogging.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health.checks;
2 |
3 | import org.jboss.logging.BasicLogger;
4 | import org.jboss.logging.Logger;
5 | import org.jboss.logging.annotations.Cause;
6 | import org.jboss.logging.annotations.LogMessage;
7 | import org.jboss.logging.annotations.Message;
8 | import org.jboss.logging.annotations.MessageLogger;
9 |
10 | @MessageLogger(projectCode = "SRHCK", length = 5)
11 | interface HealthChecksLogging extends BasicLogger {
12 | HealthChecksLogging logger = Logger.getMessageLogger(HealthChecksLogging.class,
13 | HealthChecksLogging.class.getPackage().getName());
14 |
15 | @LogMessage(level = Logger.Level.ERROR)
16 | @Message(id = 2000, value = "Reporting Socket health check error ")
17 | void socketHealthCheckError(@Cause Throwable throwable);
18 |
19 | @LogMessage(level = Logger.Level.ERROR)
20 | @Message(id = 2001, value = "Reporting InetAddress health check error ")
21 | void inetAddressHealthCheckError(@Cause Throwable throwable);
22 |
23 | @LogMessage(level = Logger.Level.ERROR)
24 | @Message(id = 2002, value = "Reporting URL health check error ")
25 | void urlHealthCheckError(@Cause Throwable throwable);
26 | }
27 |
--------------------------------------------------------------------------------
/testsuite/tck/src/main/java/io/smallrye/health/SmallRyeHealthGroupServlet.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health;
2 |
3 | import java.io.IOException;
4 |
5 | import jakarta.inject.Inject;
6 | import jakarta.servlet.annotation.WebServlet;
7 | import jakarta.servlet.http.HttpServlet;
8 | import jakarta.servlet.http.HttpServletRequest;
9 | import jakarta.servlet.http.HttpServletResponse;
10 |
11 | @SuppressWarnings("serial")
12 | @WebServlet(name = "SmallRyeHealthGroupServlet", urlPatterns = "/health/group/*")
13 | public class SmallRyeHealthGroupServlet extends HttpServlet {
14 |
15 | @Override
16 | protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
17 |
18 | String pathInfo = req.getPathInfo();
19 | SmallRyeHealth health = pathInfo != null ? reporter.getHealthGroup(pathInfo.substring(1)) : reporter.getHealthGroups();
20 | if (health.isDown()) {
21 | resp.setStatus(503);
22 | }
23 | try {
24 | reporter.reportHealth(resp.getOutputStream(), health);
25 | } catch (IOException ioe) {
26 | HealthLogging.logger.error(ioe);
27 | resp.setStatus(500);
28 | }
29 | }
30 |
31 | @Inject
32 | private SmallRyeHealthReporter reporter;
33 | }
34 |
--------------------------------------------------------------------------------
/.github/workflows/publish-tck.yml:
--------------------------------------------------------------------------------
1 | name: Publish TCK
2 |
3 | on:
4 | workflow_call:
5 | inputs:
6 | version:
7 | required: true
8 | description: Tag version to perform release
9 | type: string
10 |
11 | jobs:
12 | publish-tck:
13 | name: Publish TCK
14 | runs-on: ubuntu-latest
15 | strategy:
16 | matrix:
17 | java: [ 17, 21 ]
18 |
19 | steps:
20 | - uses: actions/checkout@v4
21 | name: checkout ${{inputs.version}}
22 | with:
23 | ref: ${{inputs.version}}
24 |
25 | - uses: actions/setup-java@v4
26 | name: set up jdk ${{matrix.java}}
27 | with:
28 | distribution: 'temurin'
29 | java-version: ${{matrix.java}}
30 | cache: 'maven'
31 | cache-dependency-path: '**/pom.xml'
32 |
33 | - name: generate tck report for jdk ${{matrix.java}}
34 | env:
35 | GH_TOKEN: ${{secrets.GITHUB_TOKEN}}
36 | ZIP_NAME: smallrye-health-${{inputs.version}}-tck-results-java-${{matrix.java}}.zip
37 | run: |
38 | mvn -B formatter:validate verify --file pom.xml
39 | cd testsuite/tck/target
40 | zip -r $ZIP_NAME surefire-reports/
41 | gh release upload ${{inputs.version}} $ZIP_NAME
42 |
--------------------------------------------------------------------------------
/provided-checks/src/test/java/io/smallrye/health/checks/InetAddressHealthCheckTest.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health.checks;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertEquals;
4 |
5 | import org.eclipse.microprofile.health.HealthCheckResponse;
6 | import org.junit.jupiter.api.Test;
7 |
8 | public class InetAddressHealthCheckTest {
9 |
10 | @Test
11 | public void testInetAddressCheck() {
12 | final InetAddressHealthCheck inetAddressHealthCheck = new InetAddressHealthCheck("127.0.0.1");
13 | final HealthCheckResponse healthCheckResponse = inetAddressHealthCheck.call();
14 |
15 | assertEquals(InetAddressHealthCheck.DEFAULT_NAME, healthCheckResponse.getName());
16 | assertEquals("127.0.0.1", healthCheckResponse.getData().get().get("host"));
17 | assertEquals(HealthCheckResponse.Status.UP, healthCheckResponse.getStatus());
18 | }
19 |
20 | @Test
21 | public void testInetAddressCheckNoneReachable() {
22 | final InetAddressHealthCheck inetAddressHealthCheck = new InetAddressHealthCheck("www.fdghreer.invalid");
23 | final HealthCheckResponse healthCheckResponse = inetAddressHealthCheck.call();
24 |
25 | assertEquals(HealthCheckResponse.Status.DOWN, healthCheckResponse.getStatus());
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # ignore .svn metadata files
2 | .svn
3 | # ignore Maven generated target folders
4 | ~
5 | target
6 | # ignore downloaded maven
7 | /tools/maven
8 | /tools/maven.zip
9 | # ignore eclipse files
10 | .project
11 | .classpath
12 | .settings
13 | .metadata
14 | .checkstyle
15 | # ignore m2e annotation processing files
16 | .factorypath
17 | # ignore IDEA files
18 | *.iml
19 | *.ipr
20 | *.iws
21 | .idea
22 | # ignore NetBeans files
23 | nbactions.xml
24 | nb-configuration.xml
25 | catalog.xml
26 | #
27 | maven-ant-tasks.jar
28 | test-output
29 | transaction.log
30 | # vim files
31 | *.swp
32 | /.gitk-tmp.*
33 | atlassian-ide-plugin.xml
34 | # temp files
35 | *~
36 | # maven versions plugin
37 | pom.xml.versionsBackup
38 | # hprof dumps
39 | /*.hprof
40 | # ignore 'randomly' strewn around logs
41 | server.log
42 | # ignore java crashes
43 | hs_err_pid*.log
44 | # H2 databases produced by tests
45 | *.h2.db
46 | # JBoss transaction generated files
47 | PutObjectStoreDirHere
48 | # ignore mvn-rpmbuild repo
49 | /.m2
50 | # ignore eap repo
51 | local-repo-eap
52 |
53 | #These keep hanging around
54 | arquillian/*/server.log*
55 | client/shade/dependency-reduced-pom.xml
56 |
57 | #OS X stuff
58 | .DS_Store
59 |
60 | # Zanata files
61 | **/.zanata-cache/
62 | .cache
63 |
64 | # antora
65 | doc/build
66 |
67 |
--------------------------------------------------------------------------------
/api/src/main/java/io/smallrye/health/api/AsyncHealthCheck.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health.api;
2 |
3 | import org.eclipse.microprofile.health.HealthCheckResponse;
4 |
5 | import io.smallrye.common.annotation.Experimental;
6 | import io.smallrye.mutiny.Uni;
7 |
8 | /**
9 | * The async health check procedure interface.
10 | * Invoked by consumers to verify the healthiness of a computing node in an asynchronous manner.
11 | * Unhealthy nodes are expected to be terminated.
12 | */
13 | @FunctionalInterface
14 | @Experimental("Asynchronous Health Check procedures")
15 | public interface AsyncHealthCheck {
16 |
17 | /**
18 | * Invokes the health check procedure provided by the implementation of this interface.
19 | * Unlike synchronous checks, this method is used for asynchronous checks. The returned {@code Uni}
20 | * propagates the {@code HealthCheckResponse} as item. If the returned {@code Uni} produces
21 | * a failure, the check is considered as failed. Returning {@code null} is invalid and considers the
22 | * check failed. In addition, returning a {@code Uni} propagating a {@code null} value as the item
23 | * is considered also as a failure.
24 | *
25 | * @return {@link Uni} object containing information about the health check result
26 | */
27 | Uni
14 | * {@code
15 | * @Produces
16 | * @ApplicationScoped
17 | * @Liveness
18 | * HealthCheck check1() {
19 | * return new SystemLoadHealthCheck();
20 | * }
21 | * }
22 | *
23 | */
24 | public class SystemLoadHealthCheck implements HealthCheck {
25 |
26 | double max = 0.7;
27 |
28 | public SystemLoadHealthCheck() {
29 | }
30 |
31 | public SystemLoadHealthCheck(double max) {
32 | this.max = max;
33 | }
34 |
35 | @Override
36 | public HealthCheckResponse call() {
37 | OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean();
38 |
39 | String arch = operatingSystemMXBean.getArch();
40 | String name = operatingSystemMXBean.getName();
41 | String version = operatingSystemMXBean.getVersion();
42 | int availableProcessors = operatingSystemMXBean.getAvailableProcessors();
43 |
44 | double systemLoadAverage = operatingSystemMXBean.getSystemLoadAverage();
45 | double systemLoadAveragePerProcessors = systemLoadAverage / availableProcessors;
46 |
47 | HealthCheckResponseBuilder responseBuilder = HealthCheckResponse.named("system-load")
48 | .withData("name", name)
49 | .withData("arch", arch)
50 | .withData("version", version)
51 | .withData("processors", availableProcessors)
52 | .withData("loadAverage", String.valueOf(systemLoadAverage))
53 | .withData("loadAverage per processor", String.valueOf(systemLoadAveragePerProcessors))
54 | .withData("loadAverage max", String.valueOf(max));
55 |
56 | if (systemLoadAverage > 0) {
57 | boolean status = systemLoadAveragePerProcessors < max;
58 | return responseBuilder.status(status).build();
59 | } else {
60 | // Load average not available
61 | return responseBuilder.up().build();
62 | }
63 |
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/testsuite/experimental/src/test/java/io/smallrye/health/test/SingleStartupAsyncSuccessfulTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2020-2021 Contributors to the Eclipse Foundation
3 | *
4 | * See the NOTICES file(s) distributed with this work for additional
5 | * information regarding copyright ownership.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * You may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | * SPDX-License-Identifier: Apache-2.0
20 | *
21 | */
22 |
23 | package io.smallrye.health.test;
24 |
25 | import jakarta.json.JsonArray;
26 | import jakarta.json.JsonObject;
27 |
28 | import org.jboss.arquillian.container.test.api.Deployment;
29 | import org.jboss.arquillian.container.test.api.RunAsClient;
30 | import org.jboss.shrinkwrap.api.Archive;
31 | import org.testng.Assert;
32 | import org.testng.annotations.Test;
33 |
34 | import io.smallrye.health.deployment.SuccessfulStartupAsync;
35 |
36 | /**
37 | * @author Martin Stefanko
38 | */
39 | @RunAsClient
40 | public class SingleStartupAsyncSuccessfulTest extends TCKBase {
41 |
42 | @Deployment
43 | public static Archive getDeployment() {
44 | return DeploymentUtils.createWarFileWithClasses(SingleStartupAsyncSuccessfulTest.class.getSimpleName(),
45 | SuccessfulStartupAsync.class, TCKBase.class);
46 | }
47 |
48 | /**
49 | * Verifies the startup async integration
50 | */
51 | @Test
52 | public void testSuccessResponsePayload() {
53 | Response response = getUrlStartedContents();
54 |
55 | // status code
56 | Assert.assertEquals(response.getStatus(), 200);
57 |
58 | JsonObject json = readJson(response);
59 |
60 | // response size
61 | JsonArray checks = json.getJsonArray("checks");
62 | Assert.assertEquals(checks.size(), 1, "Expected a single check response");
63 |
64 | // single procedure response
65 | assertSuccessfulCheck(checks.getJsonObject(0), "successful-check");
66 |
67 | assertOverallSuccess(json);
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/testsuite/experimental/src/test/java/io/smallrye/health/test/SingleCustomSuccessfulTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2017-2020 Contributors to the Eclipse Foundation
3 | *
4 | * See the NOTICES file(s) distributed with this work for additional
5 | * information regarding copyright ownership.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * You may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | * SPDX-License-Identifier: Apache-2.0
20 | *
21 | */
22 |
23 | package io.smallrye.health.test;
24 |
25 | import jakarta.json.JsonArray;
26 | import jakarta.json.JsonObject;
27 |
28 | import org.jboss.arquillian.container.test.api.Deployment;
29 | import org.jboss.arquillian.container.test.api.RunAsClient;
30 | import org.jboss.shrinkwrap.api.Archive;
31 | import org.testng.Assert;
32 | import org.testng.annotations.Test;
33 |
34 | import io.smallrye.health.deployment.HealthGroup12;
35 |
36 | /**
37 | * @author Antoine Sabot-Durand
38 | */
39 | @RunAsClient
40 | public class SingleCustomSuccessfulTest extends TCKBase {
41 |
42 | @Deployment
43 | public static Archive getDeployment() {
44 | return DeploymentUtils.createWarFileWithClasses(SingleCustomSuccessfulTest.class.getSimpleName(),
45 | HealthGroup12.class, TCKBase.class);
46 | }
47 |
48 | /**
49 | * Verifies the custom health integration with CDI at the scope of a server runtime
50 | */
51 | @Test
52 | public void testSuccessResponsePayload() {
53 | Response response = getUrlCustomHealthContents("health-group-1");
54 |
55 | // status code
56 | Assert.assertEquals(response.getStatus(), 200);
57 |
58 | JsonObject json = readJson(response);
59 |
60 | // response size
61 | JsonArray checks = json.getJsonArray("checks");
62 | Assert.assertEquals(checks.size(), 1, "Expected a single check response");
63 |
64 | // single procedure response
65 | assertSuccessfulCheck(checks.getJsonObject(0), "health-group-12");
66 |
67 | assertOverallSuccess(json);
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/doc/modules/ROOT/pages/health-groups.adoc:
--------------------------------------------------------------------------------
1 | [[health-groups]]
2 | = Health Groups
3 |
4 | A health group is simply a user defined group of health checks. Namely, liveness and readiness
5 | (and experimental wellness) are predefined health groups. With this feature users are allowed to
6 | define any number of custom health groups and the individual checks that will belong to them.
7 |
8 | == Including a check in a health group
9 |
10 | To include a health check in a custom health group you can use the `HealthGroup` annotations:
11 |
12 | [source,java]
13 | ----
14 | @HealthGroup("group1") <1>
15 | @HealthGroup("group2") <2>
16 | @ApplicationScoped
17 | public class SuccessfulCustom implements HealthCheck {
18 | @Override
19 | public HealthCheckResponse call() {
20 | return HealthCheckResponse.up("successful-check");
21 | }
22 | }
23 | ----
24 | <1> The check will belong to the health group _"group1"_
25 | <2> The check will also belong to the health group _"group2"_
26 |
27 | A health check can be included in any number of health groups including the liveness and readiness:
28 |
29 | [source,java]
30 | ----
31 | @HealthGroup("custom1")
32 | @HealthGroup("different-group")
33 | @Liveness
34 | @ApplicationScoped
35 | public class GroupsCheck implements HealthCheck { ...
36 | ----
37 |
38 | == Accessing the health groups
39 |
40 | The custom health groups are exposed under the `/health/group` resource tree:
41 |
42 | |===
43 | | Path | Description
44 | | `/health/group` | All health checks in all groups
45 | | `/health/group/\{group-name}` | All health checks in the group called \{group-name}
46 | |===
47 |
48 | Please note that is totally valid to define custom health group as a liveness and/or readiness
49 | probe if required. Both liveness and readiness are shorcuts for predefined health groups.
50 |
51 | In the previous example, the `GroupsCheck` will be invoked when accessing:
52 |
53 | * `/health/group`
54 | * `/health/group/custom1`
55 | * `/health/group/different-group`
56 | * `/health/live`
57 |
58 | However, it won't be invoked for instance when accessing:
59 |
60 | * `/health/group/foobar`
61 | * `/health/ready`
62 |
63 | == Default health group
64 |
65 | The configuration property `io.smallrye.health.defaultHealthGroup=\{default-group-name}` can be used to specify the health
66 | group name of a new, default health group that is implicitly added to the all
67 | health checks that don't already belong into any health group. This might be useful to easily categorize the custom health groups.
68 |
69 | == References
70 |
71 | * https://github.com/smallrye/smallrye-health/blob/main/api/src/main/java/io/smallrye/health/api/HealthGroup.java[`HealthGroup`]
72 |
73 |
--------------------------------------------------------------------------------
/testsuite/experimental/src/test/java/io/smallrye/health/test/WellnessSuccessfulTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2020 Contributors to the Eclipse Foundation
3 | *
4 | * See the NOTICES file(s) distributed with this work for additional
5 | * information regarding copyright ownership.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * You may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | * SPDX-License-Identifier: Apache-2.0
20 | *
21 | */
22 |
23 | package io.smallrye.health.test;
24 |
25 | import jakarta.json.JsonArray;
26 | import jakarta.json.JsonObject;
27 |
28 | import org.jboss.arquillian.container.test.api.Deployment;
29 | import org.jboss.arquillian.container.test.api.RunAsClient;
30 | import org.jboss.shrinkwrap.api.Archive;
31 | import org.testng.Assert;
32 | import org.testng.annotations.Test;
33 |
34 | import io.smallrye.health.deployment.SuccessfulWellness;
35 | import io.smallrye.health.deployment.SuccessfulWellnessAsync;
36 |
37 | /**
38 | * @author Antoine Sabot-Durand
39 | */
40 | @RunAsClient
41 | public class WellnessSuccessfulTest extends TCKBase {
42 |
43 | @Deployment
44 | public static Archive getDeployment() {
45 | return DeploymentUtils.createWarFileWithClasses(WellnessSuccessfulTest.class.getSimpleName(),
46 | SuccessfulWellness.class, SuccessfulWellnessAsync.class, TCKBase.class);
47 | }
48 |
49 | /**
50 | * Verifies the wellness integration with CDI at the scope of a server runtime
51 | */
52 | @Test
53 | public void testSuccessResponsePayload() {
54 | Response response = getUrlWellContents();
55 |
56 | // status code
57 | Assert.assertEquals(response.getStatus(), 200);
58 |
59 | JsonObject json = readJson(response);
60 |
61 | // response size
62 | JsonArray checks = json.getJsonArray("checks");
63 | Assert.assertEquals(checks.size(), 2, "Expected two check responses");
64 |
65 | // single procedure response
66 | assertSuccessfulCheck(checks.getJsonObject(0), "successful-check");
67 | assertSuccessfulCheck(checks.getJsonObject(1), "successful-check");
68 |
69 | assertOverallSuccess(json);
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/implementation/src/main/java/io/smallrye/health/registry/HealthRegistryImpl.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health.registry;
2 |
3 | import java.util.Collection;
4 | import java.util.HashMap;
5 | import java.util.Map;
6 | import java.util.stream.Collectors;
7 | import java.util.stream.Stream;
8 |
9 | import org.eclipse.microprofile.health.HealthCheck;
10 | import org.eclipse.microprofile.health.HealthCheckResponse;
11 |
12 | import io.smallrye.health.AsyncHealthCheckFactory;
13 | import io.smallrye.health.api.AsyncHealthCheck;
14 | import io.smallrye.health.api.HealthRegistry;
15 | import io.smallrye.mutiny.Uni;
16 |
17 | public class HealthRegistryImpl implements HealthRegistry {
18 |
19 | Map
16 | * {@code
17 | * @Produces
18 | * @ApplicationScoped
19 | * @Liveness
20 | * HealthCheck check1() {
21 | * return new SocketHealthCheck("192.168.0.2", 5432);
22 | * }
23 | * }
24 | *
25 | *
26 | * @see Socket
27 | */
28 | public class SocketHealthCheck implements HealthCheck {
29 |
30 | static final String DEFAULT_NAME = "Socket Check";
31 | static final int DEFAULT_TIMEOUT = 2000;
32 |
33 | private String host;
34 | private String name;
35 | private int port;
36 | private int timeout;
37 |
38 | public SocketHealthCheck(String host, int port) {
39 | this.host = host;
40 | this.port = port;
41 | this.name = DEFAULT_NAME;
42 | this.timeout = DEFAULT_TIMEOUT;
43 | }
44 |
45 | @Override
46 | public HealthCheckResponse call() {
47 | HealthCheckResponseBuilder healthCheckResponseBuilder = HealthCheckResponse
48 | .named(name);
49 | healthCheckResponseBuilder.withData("host", String.format("%s:%d", this.host, this.port));
50 | try (Socket s = new Socket()) {
51 | final SocketAddress socketAddress = new InetSocketAddress(host, port);
52 | s.connect(socketAddress, timeout);
53 | healthCheckResponseBuilder.up();
54 | } catch (IOException ex) {
55 | HealthChecksLogging.logger.socketHealthCheckError(ex);
56 |
57 | healthCheckResponseBuilder.withData("error", ex.getMessage());
58 | healthCheckResponseBuilder.down();
59 | }
60 | return healthCheckResponseBuilder.build();
61 | }
62 |
63 | /**
64 | * Sets the name of the health check.
65 | *
66 | * @param name of health check.
67 | * @return SocketHealthCheck instance.
68 | */
69 | public SocketHealthCheck name(String name) {
70 | this.name = name;
71 | return this;
72 | }
73 |
74 | /**
75 | * Sets timeout in millis.
76 | *
77 | * @param timeout in millis.
78 | * @return SocketHealthCheck instance.
79 | */
80 | public SocketHealthCheck timeout(int timeout) {
81 | this.timeout = timeout;
82 | return this;
83 |
84 | }
85 | }
86 |
--------------------------------------------------------------------------------
/implementation/src/main/java/io/smallrye/health/HealthStatus.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health;
2 |
3 | import java.security.SecureRandom;
4 | import java.util.function.BooleanSupplier;
5 |
6 | import org.eclipse.microprofile.health.HealthCheck;
7 | import org.eclipse.microprofile.health.HealthCheckResponse;
8 |
9 | public class HealthStatus {
10 |
11 | private static final SecureRandom random = new SecureRandom();
12 |
13 | /**
14 | * Creates a health check with status up.
15 | *
16 | * @param name of the health check
17 | * @return Health check with status up and given name.
18 | */
19 | public static HealthCheck up(String name) {
20 | return status(name, true);
21 | }
22 |
23 | /**
24 | * Creates a health check with status down.
25 | *
26 | * @param name of the health check
27 | * @return Health check with status down and given name.
28 | */
29 | public static HealthCheck down(String name) {
30 | return status(name, false);
31 | }
32 |
33 | /**
34 | * Creates a health check with status set from supplier and default health check name (health-check).
35 | *
36 | * @param supplier to get status.
37 | * @return Health check with given status and default name.
38 | */
39 | public static HealthCheck status(BooleanSupplier supplier) {
40 | return status(supplier.getAsBoolean());
41 | }
42 |
43 | /**
44 | * Creates a health check with given status and default health check name (health-check).
45 | *
46 | * @param status
47 | * @return Health check with given status and default name.
48 | */
49 | public static HealthCheck status(boolean status) {
50 | return status(generateRandomHealthCheckName(), status);
51 | }
52 |
53 | /**
54 | * Creates a health check with given status and health check name.
55 | *
56 | * @param name of the status.
57 | * @param supplier to get status.
58 | * @return Health check with given status and name.
59 | */
60 | public static HealthCheck status(String name, BooleanSupplier supplier) {
61 | return status(name, supplier.getAsBoolean());
62 | }
63 |
64 | /**
65 | * Creates a health check with given status and health check name.
66 | *
67 | * @param name of the status.
68 | * @param status
69 | * @return Health check with given status and name.
70 | */
71 | public static HealthCheck status(String name, boolean status) {
72 | return () -> HealthCheckResponse.named(name).status(status).build();
73 | }
74 |
75 | private static final String generateRandomHealthCheckName() {
76 | int suffix = random.nextInt(99999);
77 | return String.format("unnamed-health-check-%05d", suffix);
78 | }
79 |
80 | }
81 |
--------------------------------------------------------------------------------
/provided-checks/src/main/java/io/smallrye/health/checks/InetAddressHealthCheck.java:
--------------------------------------------------------------------------------
1 | package io.smallrye.health.checks;
2 |
3 | import java.io.IOException;
4 | import java.net.InetAddress;
5 |
6 | import org.eclipse.microprofile.health.HealthCheck;
7 | import org.eclipse.microprofile.health.HealthCheckResponse;
8 | import org.eclipse.microprofile.health.HealthCheckResponseBuilder;
9 |
10 | /**
11 | * Health check implementation to check if host is reachable using {@code java.net.InetAddress.isReachable} method.
12 | *
13 | *
14 | * {@code
15 | * @Produces
16 | * @ApplicationScoped
17 | * @Liveness
18 | * HealthCheck check1() {
19 | * return new InetAddressHealthCheck("service.com");
20 | * }
21 | * }
22 | *
23 | *
24 | * @see InetAddress
25 | */
26 | public class InetAddressHealthCheck implements HealthCheck {
27 |
28 | static final String DEFAULT_NAME = "Internet Address Check";
29 | static final int DEFAULT_TIMEOUT = 2000;
30 |
31 | private String host;
32 | private String name;
33 | private int timeout;
34 |
35 | public InetAddressHealthCheck(String host) {
36 | this.host = host;
37 | this.name = DEFAULT_NAME;
38 | this.timeout = DEFAULT_TIMEOUT;
39 | }
40 |
41 | @Override
42 | public HealthCheckResponse call() {
43 | final HealthCheckResponseBuilder healthCheckResponseBuilder = HealthCheckResponse.named(this.name);
44 | healthCheckResponseBuilder.withData("host", this.host);
45 | try {
46 | InetAddress addr = InetAddress.getByName(this.host);
47 | final boolean reachable = addr.isReachable(this.timeout);
48 | if (!reachable) {
49 | healthCheckResponseBuilder.withData("error", String.format("Host %s not reachable.", this.host));
50 | }
51 |
52 | healthCheckResponseBuilder.status(reachable);
53 | } catch (IOException e) {
54 | HealthChecksLogging.logger.inetAddressHealthCheckError(e);
55 |
56 | healthCheckResponseBuilder.withData("error", e.getMessage());
57 | healthCheckResponseBuilder.down();
58 | }
59 |
60 | return healthCheckResponseBuilder.build();
61 | }
62 |
63 | /**
64 | * Sets timeout in millis.
65 | *
66 | * @param timeout in millis.
67 | * @return InetAddressHealthCheck instance.
68 | */
69 | public InetAddressHealthCheck timeout(int timeout) {
70 | this.timeout = timeout;
71 | return this;
72 | }
73 |
74 | /**
75 | * Sets the name of the health check.
76 | *
77 | * @param name of health check.
78 | * @return InetAddressHealthCheck instance.
79 | */
80 | public InetAddressHealthCheck name(String name) {
81 | this.name = name;
82 | return this;
83 | }
84 | }
85 |
--------------------------------------------------------------------------------
/api/src/main/java/io/smallrye/health/api/HealthGroup.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2017-2020 Contributors to the Eclipse Foundation
3 | *
4 | * See the NOTICES file(s) distributed with this work for additional
5 | * information regarding copyright ownership.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * You may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | * SPDX-License-Identifier: Apache-2.0
20 | *
21 | */
22 | package io.smallrye.health.api;
23 |
24 | import static java.lang.annotation.ElementType.FIELD;
25 | import static java.lang.annotation.ElementType.METHOD;
26 | import static java.lang.annotation.ElementType.PARAMETER;
27 | import static java.lang.annotation.ElementType.TYPE;
28 | import static java.lang.annotation.RetentionPolicy.RUNTIME;
29 |
30 | import java.lang.annotation.Documented;
31 | import java.lang.annotation.Repeatable;
32 | import java.lang.annotation.Retention;
33 | import java.lang.annotation.Target;
34 |
35 | import jakarta.enterprise.util.AnnotationLiteral;
36 | import jakarta.inject.Qualifier;
37 |
38 | import io.smallrye.common.annotation.Experimental;
39 |
40 | /**
41 | *
42 | * This qualifier is used to define a custom Health Check procedure by applying a group name to it
43 | *
44 | * @author Antoine Sabot-Durand
45 | *
46 | */
47 | @Target({ TYPE, METHOD, PARAMETER, FIELD })
48 | @Retention(RUNTIME)
49 | @Documented
50 | @Qualifier
51 | @Repeatable(HealthGroups.class)
52 | @Experimental("Custom health group definitions exposed at /health/group/{group-name}. Not covered by the specification. " +
53 | "Subject to change.")
54 | public @interface HealthGroup {
55 |
56 | /**
57 | * @return name of the custom group
58 | */
59 | String value();
60 |
61 | /**
62 | * Support inline instantiation of the {@link HealthGroup} qualifier.
63 | *
64 | * @author Antoine Sabot-Durand
65 | * @since 2.2
66 | */
67 | final class Literal extends AnnotationLiteral
15 | * {@code
16 | * @Produces
17 | * @ApplicationScoped
18 | * @Liveness
19 | * HealthCheck check1() {
20 | * return new UrlHealthCheck("www.google.com");
21 | * }
22 | * }
23 | *
24 | *
25 | * @see Socket
26 | */
27 | public class UrlHealthCheck implements HealthCheck {
28 |
29 | static final String DEFAULT_NAME = "Url Check";
30 | static final int DEFAULT_TIMEOUT = 2000;
31 | static final String DEFAULT_REQUEST_METHOD = "GET";
32 | static final int DEFAULT_EXPECTED_STATUS_CODE = HttpURLConnection.HTTP_OK;
33 |
34 | private String url;
35 | private String name;
36 | private int timeout;
37 | private String requestMethod;
38 | private int statusCode;
39 |
40 | public UrlHealthCheck(String url) {
41 | this.url = url;
42 | this.requestMethod = DEFAULT_REQUEST_METHOD;
43 | this.statusCode = DEFAULT_EXPECTED_STATUS_CODE;
44 | this.name = DEFAULT_NAME;
45 | this.timeout = DEFAULT_TIMEOUT;
46 | }
47 |
48 | @Override
49 | public HealthCheckResponse call() {
50 | final HealthCheckResponseBuilder healthCheckResponseBuilder = HealthCheckResponse
51 | .named(name);
52 | healthCheckResponseBuilder.withData("host", String.format("%s %s", this.requestMethod, this.url));
53 | HttpURLConnection httpUrlConn = null;
54 | try {
55 | httpUrlConn = (HttpURLConnection) new URL(this.url)
56 | .openConnection();
57 |
58 | httpUrlConn.setRequestMethod(requestMethod);
59 |
60 | httpUrlConn.setConnectTimeout(timeout);
61 | httpUrlConn.setReadTimeout(timeout);
62 |
63 | final boolean isUp = httpUrlConn.getResponseCode() == statusCode;
64 |
65 | if (!isUp) {
66 | healthCheckResponseBuilder.withData("error", String.format("Expected response code %d but actual is %d",
67 | statusCode, httpUrlConn.getResponseCode()));
68 | }
69 |
70 | healthCheckResponseBuilder.status(isUp);
71 |
72 | } catch (Exception e) {
73 | HealthChecksLogging.logger.urlHealthCheckError(e);
74 |
75 | healthCheckResponseBuilder.withData("error",
76 | String.format("%s: %s", e.getClass().getCanonicalName(), e.getMessage()));
77 | healthCheckResponseBuilder.down();
78 | } finally {
79 | if (httpUrlConn != null) {
80 | httpUrlConn.disconnect();
81 | }
82 | }
83 |
84 | return healthCheckResponseBuilder.build();
85 | }
86 |
87 | /**
88 | * Sets the name of the health check.
89 | *
90 | * @param name of health check.
91 | * @return UrlHealthCheck instance.
92 | */
93 | public UrlHealthCheck name(String name) {
94 | this.name = name;
95 | return this;
96 | }
97 |
98 | /**
99 | * Sets timeout in millis.
100 | *
101 | * @param timeout in millis.
102 | * @return UrlHealthCheck instance.
103 | */
104 | public UrlHealthCheck timeout(int timeout) {
105 | this.timeout = timeout;
106 | return this;
107 | }
108 |
109 | /**
110 | * Sets the expected status code to be returned as valid.
111 | *
112 | * @param statusCode expected.
113 | * @return UrlHealthCheck instance.
114 | */
115 | public UrlHealthCheck statusCode(int statusCode) {
116 | this.statusCode = statusCode;
117 | return this;
118 | }
119 |
120 | /**
121 | * Sets the request method to be used (ie GET, POST, PUT, ...)
122 | *
123 | * @param requestMethod to use.
124 | * @return UrlHealthCheck instance.
125 | */
126 | public UrlHealthCheck requestMethod(String requestMethod) {
127 | this.requestMethod = requestMethod;
128 | return this;
129 | }
130 |
131 | }
132 |
--------------------------------------------------------------------------------
/testsuite/experimental/src/test/java/io/smallrye/health/test/HealthContentFilterTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2020 Contributors to the Eclipse Foundation
3 | *
4 | * See the NOTICES file(s) distributed with this work for additional
5 | * information regarding copyright ownership.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * You may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | * SPDX-License-Identifier: Apache-2.0
20 | *
21 | */
22 |
23 | package io.smallrye.health.test;
24 |
25 | import jakarta.json.JsonArray;
26 | import jakarta.json.JsonObject;
27 |
28 | import org.jboss.arquillian.container.test.api.Deployment;
29 | import org.jboss.arquillian.container.test.api.OperateOnDeployment;
30 | import org.jboss.arquillian.container.test.api.RunAsClient;
31 | import org.jboss.shrinkwrap.api.Archive;
32 | import org.testng.Assert;
33 | import org.testng.annotations.Test;
34 |
35 | import io.smallrye.health.deployment.SuccessLiveness;
36 | import io.smallrye.health.deployment.TestHealthContentFilter;
37 | import io.smallrye.health.deployment.TestHealthContentFilter2;
38 |
39 | @RunAsClient
40 | public class HealthContentFilterTest extends TCKBase {
41 |
42 | private static final String DEPLOYMENT_1 = "deployment1";
43 | private static final String DEPLOYMENT_2 = "deployment2";
44 |
45 | @Deployment(name = DEPLOYMENT_1)
46 | public static Archive getDeployment() {
47 | return DeploymentUtils.createWarFileWithClasses(HealthContentFilterTest.class.getSimpleName(),
48 | TestHealthContentFilter.class, SuccessLiveness.class, TCKBase.class);
49 | }
50 |
51 | @Deployment(name = DEPLOYMENT_2)
52 | public static Archive getDeployment2() {
53 | return DeploymentUtils.createWarFileWithClasses(HealthContentFilterTest.class.getSimpleName() + "2",
54 | TestHealthContentFilter.class, TestHealthContentFilter2.class, SuccessLiveness.class, TCKBase.class);
55 | }
56 |
57 | /**
58 | * Verifies that the filter implementations process the payload before its returned to the caller.
59 | */
60 | @Test
61 | @OperateOnDeployment(DEPLOYMENT_1)
62 | public void testHealthContentFilterFiltersReturnedJson() {
63 | Response response = getUrlHealthContents();
64 |
65 | // status code
66 | Assert.assertEquals(response.getStatus(), 200);
67 |
68 | JsonObject json = readJson(response);
69 |
70 | // response size
71 | JsonArray checks = json.getJsonArray("checks");
72 | Assert.assertEquals(checks.size(), 1, "Expected one check response");
73 |
74 | JsonObject checkJson = checks.getJsonObject(0);
75 | Assert.assertEquals(SuccessLiveness.class.getName(), checkJson.getString("name"));
76 | verifySuccessStatus(checkJson);
77 |
78 | assertOverallSuccess(json);
79 |
80 | System.out.println(json);
81 | Assert.assertEquals("bar", json.getString("foo"));
82 | }
83 |
84 | /**
85 | * Verifies that the filter implementations process the payload before its returned to the caller.
86 | */
87 | @Test
88 | @OperateOnDeployment(DEPLOYMENT_2)
89 | public void testMultipleHealthContentFiltersFilterReturnedJson() {
90 | Response response = getUrlHealthContents();
91 |
92 | // status code
93 | Assert.assertEquals(response.getStatus(), 200);
94 |
95 | JsonObject json = readJson(response);
96 |
97 | // response size
98 | JsonArray checks = json.getJsonArray("checks");
99 | Assert.assertEquals(checks.size(), 1, "Expected one check response");
100 |
101 | JsonObject checkJson = checks.getJsonObject(0);
102 | Assert.assertEquals(SuccessLiveness.class.getName(), checkJson.getString("name"));
103 | verifySuccessStatus(checkJson);
104 |
105 | assertOverallSuccess(json);
106 |
107 | System.out.println(json);
108 | Assert.assertEquals("bar", json.getString("foo"));
109 | Assert.assertEquals("bar2", json.getString("foo2"));
110 | }
111 |
112 | }
113 |
--------------------------------------------------------------------------------
/testsuite/experimental/src/test/java/io/smallrye/health/test/DisableHealthCheckTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2022 Contributors to the Eclipse Foundation
3 | *
4 | * See the NOTICES file(s) distributed with this work for additional
5 | * information regarding copyright ownership.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * You may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | * SPDX-License-Identifier: Apache-2.0
20 | *
21 | */
22 |
23 | package io.smallrye.health.test;
24 |
25 | import jakarta.json.JsonArray;
26 | import jakarta.json.JsonObject;
27 |
28 | import org.jboss.arquillian.container.test.api.Deployment;
29 | import org.jboss.arquillian.container.test.api.OperateOnDeployment;
30 | import org.jboss.arquillian.container.test.api.RunAsClient;
31 | import org.jboss.shrinkwrap.api.Archive;
32 | import org.jboss.shrinkwrap.api.asset.StringAsset;
33 | import org.testng.Assert;
34 | import org.testng.annotations.Test;
35 |
36 | import io.smallrye.health.deployment.SuccessLiveness;
37 | import io.smallrye.health.deployment.SuccessLivenessAsync;
38 | import io.smallrye.health.deployment.SuccessReadiness;
39 | import io.smallrye.health.deployment.SuccessReadinessAsync;
40 |
41 | @RunAsClient
42 | public class DisableHealthCheckTest extends TCKBase {
43 |
44 | private static final String SYNC_DEPLOYMENT = "syncDeployment";
45 | private static final String ASYNC_DEPLOYMENT = "asyncDeployment";
46 |
47 | @Deployment(name = SYNC_DEPLOYMENT)
48 | public static Archive getSyncDeployment() {
49 | return DeploymentUtils.createWarFileWithClasses(DisableHealthCheckTest.class.getSimpleName() + "-sync",
50 | SuccessLiveness.class, SuccessReadiness.class, TCKBase.class)
51 | .addAsManifestResource(
52 | new StringAsset("io.smallrye.health.check." + SuccessLiveness.class.getName() + ".enabled=false"),
53 | "microprofile-config.properties");
54 | }
55 |
56 | @Deployment(name = ASYNC_DEPLOYMENT)
57 | public static Archive getAsyncDeployment() {
58 | return DeploymentUtils.createWarFileWithClasses(DisableHealthCheckTest.class.getSimpleName() + "-async",
59 | SuccessLivenessAsync.class, SuccessReadinessAsync.class, TCKBase.class)
60 | .addAsManifestResource(
61 | new StringAsset("io.smallrye.health.check." + SuccessLivenessAsync.class.getName() + ".enabled=false"),
62 | "microprofile-config.properties");
63 | }
64 |
65 | @Test
66 | @OperateOnDeployment(SYNC_DEPLOYMENT)
67 | public void testAdditionalProperties() {
68 | Response response = getUrlHealthContents();
69 |
70 | Assert.assertEquals(response.getStatus(), 200);
71 |
72 | JsonObject json = readJson(response);
73 |
74 | // response size, SuccessLiveness is in the deployment but it should not be included in the response
75 | JsonArray checks = json.getJsonArray("checks");
76 | Assert.assertEquals(checks.size(), 1, "Expected one check response");
77 |
78 | JsonObject checkJson = checks.getJsonObject(0);
79 | Assert.assertEquals(SuccessReadiness.class.getName(), checkJson.getString("name"));
80 | verifySuccessStatus(checkJson);
81 |
82 | assertOverallSuccess(json);
83 | }
84 |
85 | @Test
86 | @OperateOnDeployment(ASYNC_DEPLOYMENT)
87 | public void testAdditionalPropertiesAsync() {
88 | Response response = getUrlHealthContents();
89 |
90 | Assert.assertEquals(response.getStatus(), 200);
91 |
92 | JsonObject json = readJson(response);
93 |
94 | // response size, SuccessLivenessAsync is in the deployment but it should not be included in the response
95 | JsonArray checks = json.getJsonArray("checks");
96 | Assert.assertEquals(checks.size(), 1, "Expected one check response");
97 |
98 | JsonObject checkJson = checks.getJsonObject(0);
99 | Assert.assertEquals(SuccessReadinessAsync.class.getName(), checkJson.getString("name"));
100 | verifySuccessStatus(checkJson);
101 |
102 | assertOverallSuccess(json);
103 | }
104 | }
105 |
--------------------------------------------------------------------------------
/ui/src/main/webapp/health-ui/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |