Java Application Monitoring Guide: JVM Metrics, Spring Boot & APM (2026)

<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

# application.properties
management.server.port=8081
management.endpoints.web.exposure.include=health,info,prometheus,metrics
management.metrics.export.prometheus.enabled=true
management.endpoint.health.show-details=always

# Prometheus scrape config
scrape_configs:
  - job_name: 'spring-boot-app'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['localhost:8081']
    scrape_interval: 15s

@Service
public class OrderService {
    private final MeterRegistry meterRegistry;
    private final Counter ordersProcessed;
    private final Timer orderProcessingTime;

    public OrderService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.ordersProcessed = Counter.builder("orders.processed")
            .description("Total orders processed")
            .tag("environment", "production")
            .register(meterRegistry);

        this.orderProcessingTime = Timer.builder("order.processing.duration")
            .description("Time to process an order")
            .publishPercentiles(0.5, 0.95, 0.99)
            .register(meterRegistry);
    }

    // @Timed annotation alternative
    @Timed(value = "order.processing.duration", percentiles = {0.95, 0.99})
    public Order processOrder(OrderRequest request) {
        ordersProcessed.increment();
        return orderRepository.save(/* ... */);
    }
}

# Java 11+ JVM flags (add to JAVA_OPTS or Dockerfile CMD)
-Xms2g -Xmx4g
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-Xlog:gc*:file=/var/log/app/gc.log:time,uptime:filecount=5,filesize=20m
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/var/log/app/
-XX:+ExitOnOutOfMemoryError

# G1GC is default since Java 9 — good all-around choice
# For high-throughput services: -XX:+UseParallelGC
# For low-latency (< 10ms pauses): -XX:+UseZGC (Java 15+) or -XX:+UseShenandoahGC

# What to look for in GC logs:
# [GC pause (G1 Evacuation Pause) (young) 2048M->512M(4096M), 0.1234567 secs]
#                                                                ^^^^^^^^^^
#                           Pause time — alert if > 500ms
#
# Full GC events (non-young): usually a problem
# [Full GC (Ergonomics) 3904M->2048M(4096M), 5.234 secs]
#                       Old gen barely shrank — memory leak likely

# Spring Boot thread pool metrics (via Actuator)
# Tomcat thread pool (for web requests)
tomcat.threads.busy          # Active request-handling threads
tomcat.threads.current       # Total allocated threads
tomcat.threads.config.max    # Maximum configured (default: 200)

# Alert when:
# tomcat.threads.busy / tomcat.threads.config.max > 0.8

# Custom executor monitoring
@Configuration
public class ThreadPoolConfig {
    @Bean
    public ThreadPoolTaskExecutor asyncExecutor(MeterRegistry registry) {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-");
        executor.initialize();

        // Wrap with Micrometer for monitoring
        return ExecutorServiceMetrics.monitor(
            registry, executor, "async_executor"
        );
    }
}

# Detect thread deadlocks via JMX
# jstack <pid> | grep -A3 "BLOCKED"
# Or programmatically:
ThreadMXBean tmx = ManagementFactory.getThreadMXBean();
long[] deadlockedThreads = tmx.findDeadlockedThreads();

groups:
  - name: java-jvm
    rules:
      # Heap near OOM
      - alert: JVMHeapCritical
        expr: |
          jvm_memory_used_bytes{area="heap"} /
          jvm_memory_max_bytes{area="heap"} > 0.85
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "JVM heap > 85% — OOM risk"

      # Old generation growth (leak signal)
      - alert: JVMOldGenGrowth
        expr: |
          (jvm_memory_used_bytes{id="G1 Old Gen"}
          - jvm_memory_used_bytes{id="G1 Old Gen"} offset 1h)
          / jvm_memory_used_bytes{id="G1 Old Gen"} offset 1h > 0.2
        for: 30m
        labels:
          severity: warning
        annotations:
          summary: "JVM old gen grew >20% in 1h — potential memory leak"

      # GC overhead too high
      - alert: JVMGCOverhead
        expr: |
          sum(rate(jvm_gc_pause_seconds_sum[5m]))
          / sum(rate(jvm_gc_pause_seconds_count[5m])) > 0.1
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "JVM spending >10% of time in GC"

      # Thread pool saturation
      - alert: TomcatThreadPoolSaturated
        expr: |
          tomcat_threads_busy_threads /
          tomcat_threads_config_max_threads > 0.8
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Tomcat thread pool >80% used — add workers or scale"

      # High p95 latency
      - alert: SpringBootHighLatency
        expr: |
          histogram_quantile(0.95, rate(
            http_server_requests_seconds_bucket[5m]
          )) > 2
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Spring Boot p95 latency > 2 seconds"