Application Real-Time Monitoring Service:Monitor JVM applications with Managed Service for Prometheus

How it works

The monitoring pipeline has four stages:

1. Instrument -- Add the Prometheus client library to your JVM application so it exposes metrics on an HTTP endpoint.

2. Deploy -- Build a container image, push it to Container Registry, and deploy the application to an ACK cluster.

3. Scrape -- Configure a ServiceMonitor in Managed Service for Prometheus to discover and scrape the metrics endpoint automatically.

4. Visualize -- View the collected JVM metrics in a Managed Service for Grafana dashboard and create alert rules.

JVM metrics collected

The simpleclient_hotspot library exposes standard JVM metrics in the following categories:

Prerequisites

Before you begin, make sure that you have:

• An ACK cluster is monitored by Managed Service for Prometheus. For more information, see Monitor an ACK cluster

• An image repository in Container Registry. For more information, see Step 2: Create an image repository

Sample project

A complete sample project is available on GitHub. The file paths referenced below correspond to that repository.

Step 1: Instrument the JVM application

Add the Prometheus client library to your Spring Boot application so it exposes JVM metrics on a dedicated HTTP endpoint.

1. Add the simpleclient_hotspot dependency to pom.xml.

      <dependency>
          <groupId>io.prometheus</groupId>
          <artifactId>simpleclient_hotspot</artifactId>
          <version>0.6.0</version>
      </dependency>

2. Register the default JVM metrics collectors by adding the following method to your controller class. DefaultExports.initialize() registers collectors for memory pools, GC, threads, and class loading. The @PostConstruct annotation runs this method once at application startup. See /src/main/java/com/monitise/prometheus_demo/DemoController.java in the sample project.

      @PostConstruct
          public void initJvmExporter() {
              io.prometheus.client.hotspot.DefaultExports.initialize();
          }

3. Configure the metrics port and path in application.properties. Port 8081 serves metrics separately from the application port (8080). The path /prometheus-metrics is where Prometheus sends scrape requests. See /src/main/resources/application.properties in the sample project.

      management.port: 8081
      endpoints.prometheus.path: prometheus-metrics

4. Enable the Prometheus endpoint in the main application class. @EnablePrometheusEndpoint exposes the /prometheus-metrics endpoint. @EnableSpringBootMetricsCollector exports Spring Boot actuator metrics in Prometheus format. See /src/main/java/com/monitise/prometheus_demo/PrometheusDemoApplication.java in the sample project.

      @SpringBootApplication
      // sets up the prometheus endpoint /prometheus-metrics
      @EnablePrometheusEndpoint
      // exports the data at /metrics at a prometheus endpoint
      @EnableSpringBootMetricsCollector
      public class PrometheusDemoApplication {
          public static void main(String[] args) {
              SpringApplication.run(PrometheusDemoApplication.class, args);
          }
      }

Step 2: Build and push the container image

Package the instrumented application as a Docker image and push it to Container Registry.

1. Compile the project.

      mvn clean install -DskipTests

2. Build the Docker image. Example:

      docker build -t <image-name>:<tag> . --no-cache

      docker build -t promethues-demo:v0 . --no-cache

3. Tag the image for Container Registry. Example:

      sudo docker tag <image-name>:<tag> <registry-domain>/<namespace>/<image-name>:<tag>

      sudo docker tag promethues-demo:v0 registry.cn-hangzhou.aliyuncs.com/testnamespace/promethues-demo:v0

4. Push the image to Container Registry. Example:

      sudo docker push <registry-domain>/<namespace>/<image-name>:<tag>

      sudo docker push registry.cn-hangzhou.aliyuncs.com/testnamespace/promethues-demo:v0

5. Verify the upload. Open the Container Registry console, navigate to your repository, and confirm the image appears on the Tags page.

   

Replace the placeholders with your values:

Step 3: Deploy to the ACK cluster

Deploy the JVM application to your ACK cluster and expose it as a Kubernetes Service.

Step 4: Configure service discovery

Configure a ServiceMonitor in Managed Service for Prometheus to automatically discover and scrape the JVM metrics endpoint. For detailed instructions, see Use ServiceMonitors to discover and monitor Services.

Verify the setup

After you complete all four steps, confirm that JVM metrics flow into Prometheus:

1. Open the Managed Service for Prometheus console and navigate to your ACK cluster.

2. On the Targets page, verify that your application pods appear as active scrape targets with a status of UP.

3. Open a Grafana dashboard and run a query such as jvm_memory_bytes_used to confirm data is flowing.

Troubleshooting

If metrics do not appear, check the following:

What to do next

• Set up a Grafana dashboard -- Community dashboard templates such as JVM (Micrometer) or JVM (Prometheus) provide a ready-made starting point for visualizing JVM metrics.

• Create alert rules -- Configure alerts for heap memory usage, long GC pauses, or thread count spikes. For more information, see the alert configuration documentation for Managed Service for Prometheus.