Keeping Java applications in tip-top shape is essential. With Micronaut, watching over your app’s health and performance is a breeze. Micronaut is this modern, snazzy JVM-based framework, packed with cool tools for managing your app’s metrics and health. Let’s dive into how you can use Micronaut to effectively keep an eye on your Java application.

To get started with Micronaut, you need to create a new project. It’s super simple using the Micronaut CLI, which supports Java, Kotlin, and Groovy. Here’s the magic command:

$ mn create-app myapp

And voila! Your basic Micronaut app structure is ready to go in seconds.

Now, Micronaut has this awesome feature called the health endpoint. It’s like a full-body check-up for your app. To enable it, you gotta add the micronaut-management dependency to your project. Just pop this into your build.gradle file:

dependencies {
    implementation("io.micronaut:micronaut-management")
}

As soon as this dependency is in place, Micronaut automatically gives you a /health endpoint. This endpoint spills the beans on your app’s health, covering everything from disk space to database status.

But hey, don’t just settle for the basics! Micronaut lets you add custom health indicators, letting you tailor the health reports to your specific needs. Implementing a custom indicator is a cinch. Imagine you want to check if a remote URL is responsive. Here’s how you can do it:

import io.micronaut.health.HealthStatus;
import io.micronaut.http.HttpRequest;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.client.Client;
import io.micronaut.http.client.RxHttpClient;
import io.micronaut.management.health.indicator.HealthIndicator;
import io.micronaut.management.health.indicator.HealthResult;
import org.reactivestreams.Publisher;

import javax.inject.Singleton;

@Singleton
public class RemoteUrlHealthIndicator implements HealthIndicator {

    private static final String NAME = "remote-url-health";
    private static final String URL = "http://www.example.com/";

    private final RxHttpClient client;

    public RemoteUrlHealthIndicator(@Client(URL) RxHttpClient client) {
        this.client = client;
    }

    @Override
    public Publisher<HealthResult> getResult() {
        return client.exchange(HttpRequest.HEAD("/"))
                .map(this::checkStatusCode)
                .onErrorReturn(HealthResult.builder(NAME, HealthStatus.DOWN).build());
    }

    private HealthResult checkStatusCode(HttpResponse<?> response) {
        if (response.code().is2xxSuccessful()) {
            return HealthResult.healthy(NAME);
        } else {
            return HealthResult.unhealthy(NAME);
        }
    }
}

This nifty little piece of code checks if a remote URL can be reached and reports back its status on the /health endpoint. You get insight into way more than just local metrics.

Flexibility is key, and Micronaut lets you tweak what the health endpoint shows, and you can even lock it down with security settings if needed. Interested in more detailed health info? Just enable it in your config file like this:

micronaut:
  health:
    detailed: true

Worried about prying eyes? Secure your endpoint:

micronaut:
  security:
    token:
      jwt:
        enabled: true
  health:
    endpoints: 
      health:
        enabled: true
        sensitive: true

Health metrics? Covered. But that’s not all. There’s another gem called Micrometer for monitoring a whole range of metrics. To start, you add the Micrometer dependency:

dependencies {
    implementation("io.micronaut.micrometer:micronaut-micrometer-core")
}

Micronaut’s got your back with various metrics binders ready to capture all sorts of data - from web metrics to system performance. Here’s how you’d configure web metrics:

micronaut:
  metrics:
    binders:
      web:
        server:
          percentiles: 0.95,0.99
          histogram: true
          slos: 0.1,0.4,0.5,2
          min: 0.1
          max: 60
        client:
          percentiles: 0.95,0.99
          histogram: true
          slos: 0.1,0.4,0.5,2
          min: 0.1
          max: 60

This config tracks things like request times, status codes, and more. You’ll get a wealth of data on how your application is performing under various conditions.

It’s not just about setting up these tools; you need to ensure they work! Testing the health endpoint is a smart move. You can write tests using Micronaut’s testing features to make sure everything is in top shape:

import io.micronaut.http.HttpRequest;
import io.micronaut.http.HttpStatus;
import io.micronaut.http.client.HttpClient;
import io.micronaut.http.client.annotation.Client;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import org.junit.jupiter.api.Test;

import jakarta.inject.Inject;

import static org.junit.jupiter.api.Assertions.assertEquals;

@MicronautTest
public class HealthTest {

    @Inject
    @Client("/")
    HttpClient client;

    @Test
    public void healthEndpointExposed() {
        HttpStatus status = client.toBlocking().retrieve(HttpRequest.GET("/health"), HttpStatus.class);
        assertEquals(HttpStatus.OK, status);
    }
}

This test ensures that your health endpoint is exposed and doing its job right by returning a successful status code.

Monitoring the health and metrics of your Micronaut application isn’t just easy; it’s powerful. Whether you’re relying on built-in health indicators or crafting custom ones tailored to your needs, Micronaut’s features help you gain deep insight and control over your application’s performance and health.

By keeping an eye on these health metrics, you guarantee that your Java application remains in peak condition, operating smoothly and efficiently. With the right configurations and robust testing, you can be confident that your application stays healthy and continues to deliver excellent performance.