Added DefaultCpuHealthChecker

core/src/main/java/com/linecorp/armeria/server/healthcheck/CpuHealthChecker.java

@@ -0,0 +1,174 @@
+/*
+ * Copyright 2023 LINE Corporation
+ *
+ * LINE Corporation licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package com.linecorp.armeria.server.healthcheck;
+
+import static java.util.Objects.requireNonNull;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.management.ManagementFactory;
+import java.lang.management.OperatingSystemMXBean;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.function.DoubleSupplier;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+
+import com.linecorp.armeria.common.annotation.Nullable;
+
+/**
+ * A {@link HealthChecker} that reports as unhealthy when the current
+ * CPU usage or CPU load exceeds threshold. For example:
+ * <pre>{@code
+ * final CpuHealthChecker cpuHealthChecker = HealthChecker.of(10, 10);<br>
+ * final boolean healthy = cpuHealthChecker.isHealthy();
+ * }</pre>
+ */
+// Forked from <a href="https://github.com/micrometer-metrics/micrometer/blob/8339d57bef8689beb8d7a18b429a166f6595f2af/micrometer-core/src/main/java/io/micrometer/core/instrument/binder/system/ProcessorMetrics.java">ProcessorMetrics.java</a> in the micrometer core.
+final class CpuHealthChecker implements HealthChecker {
+    private static final Logger logger = LoggerFactory.getLogger(CpuHealthChecker.class);
+
+    private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
+
+    private static final DoubleSupplier currentSystemCpuUsageSupplier;
+
+    private static final DoubleSupplier currentProcessCpuUsageSupplier;
+
+    @Nullable
+    private static final OperatingSystemMXBean operatingSystemBean;
+
+    private static final Class<?> operatingSystemBeanClass;
+
+    private static final List<String> OPERATING_SYSTEM_BEAN_CLASS_NAMES = ImmutableList.of(
+            "com.ibm.lang.management.OperatingSystemMXBean", // J9
+            "com.sun.management.OperatingSystemMXBean" // HotSpot
+    );
+
+    @Nullable
+    @VisibleForTesting
+    static final MethodHandle systemCpuUsage;
+
+    @Nullable
+    @VisibleForTesting
+    static final MethodHandle processCpuUsage;
+
+    static {
+        operatingSystemBeanClass = requireNonNull(getFirstClassFound(OPERATING_SYSTEM_BEAN_CLASS_NAMES));
+        operatingSystemBean = ManagementFactory.getOperatingSystemMXBean();
+        final MethodHandle getCpuLoad = detectMethod("getCpuLoad");
+        systemCpuUsage = getCpuLoad != null ? getCpuLoad : detectMethod("getSystemCpuLoad");
+        processCpuUsage = detectMethod("getProcessCpuLoad");
+        currentSystemCpuUsageSupplier = () -> invoke(systemCpuUsage);
+        currentProcessCpuUsageSupplier = () -> invoke(processCpuUsage);
+    }
+
+    private final double targetCpuUsage;
+
+    private final DoubleSupplier systemCpuUsageSupplier;
+
+    private final DoubleSupplier processCpuUsageSupplier;
+
+    private final double targetProcessCpuLoad;
+
+    /**
+     * Instantiates a new Default cpu health checker.
+     *
+     * @param cpuUsageThreshold the target cpu usage
+     * @param processCpuLoadThreshold the target process cpu usage
+     */
+    private CpuHealthChecker(double cpuUsageThreshold, double processCpuLoadThreshold) {
+        this(cpuUsageThreshold, processCpuLoadThreshold,
+                currentSystemCpuUsageSupplier, currentProcessCpuUsageSupplier);
+    }
+
+    private CpuHealthChecker(double cpuUsageThreshold, double processCpuLoadThreshold,
+                             DoubleSupplier systemCpuUsageSupplier, DoubleSupplier processCpuUsageSupplier) {
+        this.targetCpuUsage = cpuUsageThreshold;
+        this.targetProcessCpuLoad = processCpuLoadThreshold;
+        this.systemCpuUsageSupplier = systemCpuUsageSupplier;
+        this.processCpuUsageSupplier = processCpuUsageSupplier;
+    }
+
+    private static double invoke(@Nullable MethodHandle mh) {
+        if (mh == null) {
+            return Double.NaN;
+        }
+
+        try {
+            return (double) mh.invoke(operatingSystemBean);
+        } catch (Throwable e) {
+            return Double.NaN;
+        }
+    }
+
+    @Nullable
+    @SuppressWarnings("ReturnValueIgnored")
+    private static MethodHandle detectMethod(final String name) {
+        if (operatingSystemBeanClass == null) {
+            return null;
+        }
+        try {
+            // ensure the Bean we have is actually an instance of the interface
+            operatingSystemBeanClass.cast(operatingSystemBean);
+            final Method method = operatingSystemBeanClass.getMethod(name);
+            return LOOKUP.unreflect(method);
+        } catch (ClassCastException | NoSuchMethodException | SecurityException | IllegalAccessException e) {
+            logger.warn(
+                    "Failed to detect method {}.{} for {}",
+                    operatingSystemBeanClass.getSimpleName(),
+                    name,
+                    CpuHealthChecker.class.getSimpleName(),
+                    e
+            );
+            return null;
+        }
+    }
+
+    @Nullable
+    private static Class<?> getFirstClassFound(final List<String> classNames) {
+        for (String className : classNames) {
+            try {
+                return Class.forName(className, false, CpuHealthChecker.class.getClassLoader());
+            } catch (ClassNotFoundException ignore) {
+            }
+        }
+        return null;
+    }
+
+    public static CpuHealthChecker of(double targetCpuUsage, double targetProcessCpuLoad) {
+        return new CpuHealthChecker(targetCpuUsage, targetProcessCpuLoad);
+    }
+
+    /**
+     * Returns true if and only if System CPU Usage and Processes cpu usage is below the target usage.
+     */
+    @Override
+    public boolean isHealthy() {
+        return isHealthy(systemCpuUsageSupplier, processCpuUsageSupplier);
+    }
+
+    @VisibleForTesting
+    boolean isHealthy(
+            DoubleSupplier currentSystemCpuUsageSupplier, DoubleSupplier currentProcessCpuUsageSupplier) {
+        final double currentSystemCpuUsage = currentSystemCpuUsageSupplier.getAsDouble();
+        final double currentProcessCpuUsage = currentProcessCpuUsageSupplier.getAsDouble();
+        return currentSystemCpuUsage <= targetCpuUsage && currentProcessCpuUsage <= targetProcessCpuLoad;
+    }
+}

core/src/test/java/com/linecorp/armeria/server/healthcheck/CpuHealthCheckerTest.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2023 LINE Corporation
+ *
+ * LINE Corporation licenses this file to you under the Apache License,
+ * version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at:
+ *
+ *   https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+package com.linecorp.armeria.server.healthcheck;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.lang.invoke.MethodHandle;
+
+import org.junit.jupiter.api.Test;
+
+class CpuHealthCheckerTest {
+
+    @Test
+    void shouldGatherCpuUsageInformationAndCheckHealth() {
+        final CpuHealthChecker cpuHealthChecker = CpuHealthChecker.of(3.0, 10);
+        final MethodHandle processCpuUsage = cpuHealthChecker.processCpuUsage;
+        final MethodHandle systemCpuUsage = cpuHealthChecker.systemCpuUsage;
+        assertNotNull(processCpuUsage);
+        assertNotNull(systemCpuUsage);
+        assertTrue(cpuHealthChecker.isHealthy(() -> 2.0, () -> 1.0));
+    }
+
+    @Test
+    void shouldGatherCpuUsageInformationAndCheckHealthWithBoundaryCpuUsage() {
+        final CpuHealthChecker cpuHealthChecker = CpuHealthChecker.of(3.0, 10);
+        final MethodHandle processCpuUsage = cpuHealthChecker.processCpuUsage;
+        final MethodHandle systemCpuUsage = cpuHealthChecker.systemCpuUsage;
+        assertNotNull(processCpuUsage);
+        assertNotNull(systemCpuUsage);
+        assertTrue(cpuHealthChecker.isHealthy(() -> 3.0, () -> 1.0));
+    }
+
+    @Test
+    void shouldGatherCpuUsageInformationAndCheckHealthWithBoundaryProcessUsage() {
+        final CpuHealthChecker cpuHealthChecker = CpuHealthChecker.of(3.0, 10);
+        final MethodHandle processCpuUsage = cpuHealthChecker.processCpuUsage;
+        final MethodHandle systemCpuUsage = cpuHealthChecker.systemCpuUsage;
+        assertNotNull(processCpuUsage);
+        assertNotNull(systemCpuUsage);
+        assertTrue(cpuHealthChecker.isHealthy(() -> 1.0, () -> 10.0));
+    }
+
+    @Test
+    void testGatheringCpuUsageInformation4() {
+        final CpuHealthChecker cpuHealthChecker = CpuHealthChecker.of(3.0, 10);
+        final MethodHandle processCpuUsage = cpuHealthChecker.processCpuUsage;
+        final MethodHandle systemCpuUsage = cpuHealthChecker.systemCpuUsage;
+        assertNotNull(processCpuUsage);
+        assertNotNull(systemCpuUsage);
+        assertFalse(cpuHealthChecker.isHealthy(() -> 4.0, () -> 10.0));
+    }
+
+    @Test
+    void testGatheringCpuUsageInformation5() {
+        final CpuHealthChecker cpuHealthChecker = CpuHealthChecker.of(3.0, 10);
+        final MethodHandle processCpuUsage = cpuHealthChecker.processCpuUsage;
+        final MethodHandle systemCpuUsage = cpuHealthChecker.systemCpuUsage;
+        assertNotNull(processCpuUsage);
+        assertNotNull(systemCpuUsage);
+        assertFalse(cpuHealthChecker.isHealthy(() -> 3.0, () -> 11.0));
+    }
+
+    @Test
+    void testGatheringCpuUsageInformation6() {
+        final CpuHealthChecker cpuHealthChecker = CpuHealthChecker.of(3.0, 10);
+        final MethodHandle processCpuUsage = cpuHealthChecker.processCpuUsage;
+        final MethodHandle systemCpuUsage = cpuHealthChecker.systemCpuUsage;
+        assertNotNull(processCpuUsage);
+        assertNotNull(systemCpuUsage);
+        assertFalse(cpuHealthChecker.isHealthy(() -> 4.0, () -> 11.0));
+    }
+}