Prometheus Exporter in Spring Boot in Java

Introduction to Prometheus and Spring Boot

Prometheus is a powerful open-source monitoring and alerting toolkit. When integrated with Spring Boot applications, it provides comprehensive metrics collection, monitoring, and alerting capabilities for microservices architectures.

Project Setup and Dependencies

Maven Dependencies

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"> <dependencies> <!-- Spring Boot Starter Web --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Spring Boot Starter Actuator --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> <!-- Micrometer Prometheus Registry --> <dependency> <groupId>io.micrometer</groupId> <artifactId>micrometer-registry-prometheus</artifactId> </dependency> <!-- Micrometer Core --> <dependency> <groupId>io.micrometer</groupId> <artifactId>micrometer-core</artifactId> </dependency> <!-- For JVM metrics --> <dependency> <groupId>io.github.mweirauch</groupId> <artifactId>micrometer-jvm-extras</artifactId> <version>0.2.2</version> </dependency> <!-- For database metrics --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <!-- For cache metrics --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> <!-- For testing --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> </project>

Application Configuration

# application.properties # Application server.port=8080 spring.application.name=prometheus-exporter-demo # Actuator Configuration management.server.port=8081 management.endpoints.web.exposure.include=health,info,metrics,prometheus management.endpoint.health.show-details=always management.endpoint.metrics.enabled=true management.endpoint.prometheus.enabled=true # Metrics Configuration management.metrics.export.prometheus.enabled=true management.metrics.distribution.percentiles-histogram.http.server.requests=true management.metrics.enable.jvm=true management.metrics.enable.logback=true management.metrics.enable.system=true # Custom metrics tags management.metrics.tags.application=${spring.application.name} management.metrics.tags.environment=development # JPA (if using database) spring.datasource.url=jdbc:h2:mem:testdb spring.jpa.show-sql=true spring.jpa.hibernate.ddl-auto=create-drop # Logging (for logback metrics) logging.level.com.example=INFO

Basic Prometheus Exporter Setup

Main Application Class

package com.example.prometheus; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.scheduling.annotation.EnableScheduling; @SpringBootApplication @EnableScheduling public class PrometheusExporterApplication { public static void main(String[] args) { SpringApplication.run(PrometheusExporterApplication.class, args); } }

Basic Configuration Class

package com.example.prometheus.config; import io.micrometer.core.instrument.MeterRegistry; import io.micrometer.core.instrument.config.MeterFilter; import io.micrometer.prometheus.PrometheusMeterRegistry; import org.springframework.boot.actuate.autoconfigure.metrics.MeterRegistryCustomizer; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class MetricsConfig { @Bean public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() { return registry -> { registry.config().commonTags( "application", "prometheus-exporter-demo", "environment", "dev", "region", "us-east-1" ); }; } @Bean public MeterFilter renameUnhealthyTag() { return MeterFilter.renameTag("http.server.requests", "outcome", "status"); } @Bean public MeterFilter denyHistogramPercentiles() { return MeterFilter.denyNameStartsWith("jvm.gc.pause"); } }

Custom Metrics Exporters

Business Metrics Exporter

package com.example.prometheus.metrics; import io.micrometer.core.instrument.Counter; import io.micrometer.core.instrument.Gauge; import io.micrometer.core.instrument.MeterRegistry; import io.micrometer.core.instrument.Timer; import org.springframework.stereotype.Component; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; @Component public class BusinessMetricsExporter { private final MeterRegistry meterRegistry; private final Counter ordersCreatedCounter; private final Counter ordersFailedCounter; private final Timer orderProcessingTimer; private final AtomicInteger activeUsersGauge; private final AtomicLong revenueCounter; private final ConcurrentHashMap<String, AtomicInteger> productStockGauges; public BusinessMetricsExporter(MeterRegistry meterRegistry) { this.meterRegistry = meterRegistry; this.productStockGauges = new ConcurrentHashMap<>(); this.activeUsersGauge = new AtomicInteger(0); this.revenueCounter = new AtomicLong(0); // Initialize counters this.ordersCreatedCounter = Counter.builder("orders.created") .description("Total number of orders created") .tag("type", "business") .register(meterRegistry); this.ordersFailedCounter = Counter.builder("orders.failed") .description("Total number of failed orders") .tag("type", "business") .register(meterRegistry); // Initialize timer this.orderProcessingTimer = Timer.builder("orders.processing.time") .description("Time taken to process orders") .tag("type", "business") .publishPercentiles(0.5, 0.95, 0.99) // 50th, 95th, 99th percentiles .register(meterRegistry); // Initialize gauge for active users Gauge.builder("users.active.count", activeUsersGauge, AtomicInteger::get) .description("Number of currently active users") .tag("type", "business") .register(meterRegistry); // Initialize revenue counter as gauge Gauge.builder("revenue.total", revenueCounter, AtomicLong::get) .description("Total revenue generated") .tag("currency", "USD") .register(meterRegistry); } public void incrementOrdersCreated(String customerType) { ordersCreatedCounter.increment(); // Also increment with customer type tag Counter.builder("orders.created") .tag("customer_type", customerType) .register(meterRegistry) .increment(); } public void incrementOrdersFailed(String failureReason) { ordersFailedCounter.increment(); Counter.builder("orders.failed") .tag("reason", failureReason) .register(meterRegistry) .increment(); } public void recordOrderProcessingTime(long duration, TimeUnit unit) { orderProcessingTimer.record(duration, unit); } public Timer.Sample startOrderProcessingTimer() { return Timer.start(meterRegistry); } public void stopOrderProcessingTimer(Timer.Sample sample, String orderType) { sample.stop(Timer.builder("orders.processing.time") .tag("order_type", orderType) .register(meterRegistry)); } public void setActiveUsers(int count) { activeUsersGauge.set(count); } public void incrementActiveUsers() { activeUsersGauge.incrementAndGet(); } public void decrementActiveUsers() { activeUsersGauge.decrementAndGet(); } public void addRevenue(double amount) { revenueCounter.addAndGet((long) (amount * 100)); // Store as cents to avoid floating point } public void setProductStock(String productId, int stock) { String gaugeName = "product.stock"; productStockGauges.computeIfAbsent(productId, id -> { AtomicInteger gauge = new AtomicInteger(stock); Gauge.builder(gaugeName, gauge, AtomicInteger::get) .tag("product_id", id) .description("Current stock for product") .register(meterRegistry); return gauge; }).set(stock); } public void decrementProductStock(String productId) { AtomicInteger gauge = productStockGauges.get(productId); if (gauge != null) { gauge.decrementAndGet(); } } public void removeProductStockGauge(String productId) { AtomicInteger gauge = productStockGauges.remove(productId); if (gauge != null) { // Note: Gauges cannot be directly removed in Micrometer // They will automatically disappear when garbage collected } } }

JVM and System Metrics Exporter

package com.example.prometheus.metrics; import io.micrometer.core.instrument.Gauge; import io.micrometer.core.instrument.MeterRegistry; import io.micrometer.core.instrument.binder.MeterBinder; import org.springframework.stereotype.Component; import java.lang.management.*; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; @Component public class JvmMetricsExporter implements MeterBinder { private final AtomicInteger threadCount = new AtomicInteger(0); private final AtomicLong heapUsed = new AtomicLong(0); private final AtomicLong heapMax = new AtomicLong(0); private final AtomicInteger loadedClassCount = new AtomicInteger(0); private final AtomicLong gcCount = new AtomicLong(0); private final AtomicLong gcTime = new AtomicLong(0); @Override public void bindTo(MeterRegistry registry) { // Thread metrics Gauge.builder("jvm.threads.live", threadCount, AtomicInteger::get) .description("Current live threads") .baseUnit("threads") .register(registry); // Memory metrics Gauge.builder("jvm.memory.heap.used", heapUsed, AtomicLong::get) .description("Current heap memory used") .baseUnit("bytes") .register(registry); Gauge.builder("jvm.memory.heap.max", heapMax, AtomicLong::get) .description("Maximum heap memory") .baseUnit("bytes") .register(registry); // Class loading metrics Gauge.builder("jvm.classes.loaded", loadedClassCount, AtomicInteger::get) .description("Currently loaded classes") .baseUnit("classes") .register(registry); // GC metrics Gauge.builder("jvm.gc.count", gcCount, AtomicLong::get) .description("Total GC count") .baseUnit("collections") .register(registry); Gauge.builder("jvm.gc.time", gcTime, AtomicLong::get) .description("Total GC time") .baseUnit("milliseconds") .register(registry); // Start monitoring thread startMonitoringThread(); } private void startMonitoringThread() { Thread monitoringThread = new Thread(() -> { while (!Thread.currentThread().isInterrupted()) { try { updateMetrics(); Thread.sleep(5000); // Update every 5 seconds } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } }); monitoringThread.setDaemon(true); monitoringThread.setName("jvm-metrics-monitor"); monitoringThread.start(); } private void updateMetrics() { // Thread metrics ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); threadCount.set(threadMXBean.getThreadCount()); // Memory metrics MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean(); MemoryUsage heapUsage = memoryMXBean.getHeapMemoryUsage(); heapUsed.set(heapUsage.getUsed()); heapMax.set(heapUsage.getMax()); // Class loading metrics ClassLoadingMXBean classLoadingMXBean = ManagementFactory.getClassLoadingMXBean(); loadedClassCount.set(classLoadingMXBean.getLoadedClassCount()); // GC metrics GarbageCollectorMXBean[] gcBeans = ManagementFactory.getGarbageCollectorMXBeans(); long totalGcCount = 0; long totalGcTime = 0; for (GarbageCollectorMXBean gcBean : gcBeans) { totalGcCount += gcBean.getCollectionCount(); totalGcTime += gcBean.getCollectionTime(); } gcCount.set(totalGcCount); gcTime.set(totalGcTime); } }

Database Metrics Exporter

package com.example.prometheus.metrics; import io.micrometer.core.instrument.Counter; import io.micrometer.core.instrument.MeterRegistry; import io.micrometer.core.instrument.Timer; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; @Component public class DatabaseMetricsExporter { private final MeterRegistry meterRegistry; private final ConcurrentHashMap<String, Counter> queryCounters; private final ConcurrentHashMap<String, Timer> queryTimers; private final AtomicInteger activeConnections; private final AtomicLong totalQueries; private final AtomicInteger connectionPoolSize; public DatabaseMetricsExporter(MeterRegistry meterRegistry) { this.meterRegistry = meterRegistry; this.queryCounters = new ConcurrentHashMap<>(); this.queryTimers = new ConcurrentHashMap<>(); this.activeConnections = new AtomicInteger(0); this.totalQueries = new AtomicLong(0); this.connectionPoolSize = new AtomicInteger(10); // Default pool size initializeGauges(); } @PostConstruct public void init() { // Initialize connection pool gauge io.micrometer.core.instrument.Gauge.builder("db.connections.pool.size", connectionPoolSize, AtomicInteger::get) .description("Database connection pool size") .baseUnit("connections") .register(meterRegistry); // Initialize active connections gauge io.micrometer.core.instrument.Gauge.builder("db.connections.active", activeConnections, AtomicInteger::get) .description("Active database connections") .baseUnit("connections") .register(meterRegistry); // Initialize total queries counter as gauge io.micrometer.core.instrument.Gauge.builder("db.queries.total", totalQueries, AtomicLong::get) .description("Total database queries executed") .baseUnit("queries") .register(meterRegistry); } private void initializeGauges() { // Additional database-related gauges can be initialized here } public void recordQuery(String queryType, String table, long duration, TimeUnit unit) { // Increment total queries totalQueries.incrementAndGet(); // Record query count String counterKey = queryType + "." + table; Counter counter = queryCounters.computeIfAbsent(counterKey, key -> Counter.builder("db.queries") .tag("type", queryType) .tag("table", table) .description("Database queries by type and table") .register(meterRegistry) ); counter.increment(); // Record query duration String timerKey = queryType + "." + table; Timer timer = queryTimers.computeIfAbsent(timerKey, key -> Timer.builder("db.queries.duration") .tag("type", queryType) .tag("table", table) .description("Database query execution time") .publishPercentiles(0.5, 0.95, 0.99) .register(meterRegistry) ); timer.record(duration, unit); } public Timer.Sample startQueryTimer() { return Timer.start(meterRegistry); } public void stopQueryTimer(Timer.Sample sample, String queryType, String table) { sample.stop(Timer.builder("db.queries.duration") .tag("type", queryType) .tag("table", table) .register(meterRegistry)); } public void incrementActiveConnections() { activeConnections.incrementAndGet(); } public void decrementActiveConnections() { activeConnections.decrementAndGet(); } public void setConnectionPoolSize(int size) { connectionPoolSize.set(size); } public void recordFailedQuery(String queryType, String table, String error) { Counter.builder("db.queries.failed") .tag("type", queryType) .tag("table", table) .tag("error", error) .description("Failed database queries") .register(meterRegistry) .increment(); } public void recordSlowQuery(String queryType, String table, long thresholdMs) { Counter.builder("db.queries.slow") .tag("type", queryType) .tag("table", table) .tag("threshold_ms", String.valueOf(thresholdMs)) .description("Slow database queries") .register(meterRegistry) .increment(); } }

REST Controller with Metrics Integration

Order Controller with Metrics

package com.example.prometheus.controller; import com.example.prometheus.metrics.BusinessMetricsExporter; import com.example.prometheus.metrics.DatabaseMetricsExporter; import io.micrometer.core.instrument.Timer; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.util.HashMap; import java.util.Map; import java.util.Random; import java.util.concurrent.TimeUnit; @RestController @RequestMapping("/api/orders") public class OrderController { @Autowired private BusinessMetricsExporter businessMetrics; @Autowired private DatabaseMetricsExporter databaseMetrics; private final Random random = new Random(); @PostMapping public ResponseEntity<Map<String, Object>> createOrder(@RequestBody OrderRequest request) { Timer.Sample orderTimer = businessMetrics.startOrderProcessingTimer(); Timer.Sample dbTimer = databaseMetrics.startQueryTimer(); try { // Simulate database operation simulateDatabaseOperation("INSERT", "orders"); // Simulate business logic processing time simulateProcessingDelay(); // Record successful order businessMetrics.incrementOrdersCreated(request.getCustomerType()); businessMetrics.addRevenue(request.getAmount()); // Update product stock request.getItems().forEach(item -> businessMetrics.decrementProductStock(item.getProductId())); Map<String, Object> response = new HashMap<>(); response.put("orderId", generateOrderId()); response.put("status", "created"); response.put("timestamp", System.currentTimeMillis()); return ResponseEntity.ok(response); } catch (Exception e) { // Record failed order businessMetrics.incrementOrdersFailed("processing_error"); databaseMetrics.recordFailedQuery("INSERT", "orders", e.getMessage()); Map<String, Object> errorResponse = new HashMap<>(); errorResponse.put("error", "Order creation failed"); errorResponse.put("message", e.getMessage()); return ResponseEntity.badRequest().body(errorResponse); } finally { // Stop timers businessMetrics.stopOrderProcessingTimer(orderTimer, "standard"); databaseMetrics.stopQueryTimer(dbTimer, "INSERT", "orders"); } } @GetMapping("/{id}") public ResponseEntity<Map<String, Object>> getOrder(@PathVariable String id) { Timer.Sample dbTimer = databaseMetrics.startQueryTimer(); try { // Simulate database query simulateDatabaseOperation("SELECT", "orders"); Map<String, Object> order = new HashMap<>(); order.put("id", id); order.put("status", "completed"); order.put("amount", 99.99); return ResponseEntity.ok(order); } finally { databaseMetrics.stopQueryTimer(dbTimer, "SELECT", "orders"); } } @GetMapping("/stats") public ResponseEntity<Map<String, Object>> getOrderStats() { Map<String, Object> stats = new HashMap<>(); stats.put("totalOrders", 1500); stats.put("activeOrders", 25); stats.put("revenue", 75000.0); return ResponseEntity.ok(stats); } @PostMapping("/bulk") public ResponseEntity<Map<String, Object>> createBulkOrders(@RequestBody BulkOrderRequest request) { Timer.Sample bulkTimer = businessMetrics.startOrderProcessingTimer(); try { int successCount = 0; int failureCount = 0; for (int i = 0; i < request.getCount(); i++) { try { simulateDatabaseOperation("INSERT", "orders"); businessMetrics.incrementOrdersCreated("bulk"); successCount++; } catch (Exception e) { businessMetrics.incrementOrdersFailed("bulk_error"); failureCount++; } } Map<String, Object> response = new HashMap<>(); response.put("successCount", successCount); response.put("failureCount", failureCount); response.put("totalProcessed", request.getCount()); return ResponseEntity.ok(response); } finally { businessMetrics.stopOrderProcessingTimer(bulkTimer, "bulk"); } } private void simulateDatabaseOperation(String operation, String table) { long startTime = System.currentTimeMillis(); try { // Simulate database operation delay Thread.sleep(random.nextInt(50) + 10); // 10-60ms // Randomly simulate database errors (5% chance) if (random.nextDouble() < 0.05) { throw new RuntimeException("Database connection timeout"); } long duration = System.currentTimeMillis() - startTime; databaseMetrics.recordQuery(operation, table, duration, TimeUnit.MILLISECONDS); // Record slow queries (over 30ms) if (duration > 30) { databaseMetrics.recordSlowQuery(operation, table, 30); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RuntimeException("Database operation interrupted", e); } } private void simulateProcessingDelay() throws InterruptedException { Thread.sleep(random.nextInt(100) + 50); // 50-150ms } private String generateOrderId() { return "ORD-" + System.currentTimeMillis() + "-" + random.nextInt(1000); } // DTO classes public static class OrderRequest { private String customerType; private double amount; private java.util.List<OrderItem> items; // Getters and setters public String getCustomerType() { return customerType; } public void setCustomerType(String customerType) { this.customerType = customerType; } public double getAmount() { return amount; } public void setAmount(double amount) { this.amount = amount; } public java.util.List<OrderItem> getItems() { return items; } public void setItems(java.util.List<OrderItem> items) { this.items = items; } } public static class OrderItem { private String productId; private int quantity; // Getters and setters public String getProductId() { return productId; } public void setProductId(String productId) { this.productId = productId; } public int getQuantity() { return quantity; } public void setQuantity(int quantity) { this.quantity = quantity; } } public static class BulkOrderRequest { private int count; // Getters and setters public int getCount() { return count; } public void setCount(int count) { this.count = count; } } }

Scheduled Metrics Updates

Scheduled Metrics Collector

package com.example.prometheus.scheduler; import com.example.prometheus.metrics.BusinessMetricsExporter; import com.example.prometheus.metrics.DatabaseMetricsExporter; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import java.util.Random; @Component public class MetricsScheduler { @Autowired private BusinessMetricsExporter businessMetrics; @Autowired private DatabaseMetricsExporter databaseMetrics; private final Random random = new Random(); private int simulatedActiveUsers = 100; /** * Update active users count every 30 seconds */ @Scheduled(fixedRate = 30000) public void updateActiveUsers() { // Simulate user activity fluctuations int change = random.nextInt(21) - 10; // -10 to +10 simulatedActiveUsers = Math.max(50, simulatedActiveUsers + change); businessMetrics.setActiveUsers(simulatedActiveUsers); } /** * Simulate random orders every minute */ @Scheduled(fixedRate = 60000) public void simulateOrderCreation() { int ordersToCreate = random.nextInt(10) + 1; // 1-10 orders for (int i = 0; i < ordersToCreate; i++) { String customerType = random.nextBoolean() ? "premium" : "standard"; businessMetrics.incrementOrdersCreated(customerType); // Simulate order processing time long processingTime = random.nextInt(200) + 50; // 50-250ms businessMetrics.recordOrderProcessingTime(processingTime, java.util.concurrent.TimeUnit.MILLISECONDS); // Add random revenue double revenue = 10 + (random.nextDouble() * 90); // $10-$100 businessMetrics.addRevenue(revenue); } } /** * Update database connection metrics every 15 seconds */ @Scheduled(fixedRate = 15000) public void updateDatabaseMetrics() { // Simulate connection pool changes int poolSize = 10 + random.nextInt(11); // 10-20 connections databaseMetrics.setConnectionPoolSize(poolSize); // Simulate active connections (40-80% of pool size) int activeConnections = (int) (poolSize * (0.4 + (random.nextDouble() * 0.4))); // Update active connections (this is simplified - in real app, get from connection pool) for (int i = 0; i < activeConnections; i++) { databaseMetrics.incrementActiveConnections(); } } /** * Update product stock metrics every 2 minutes */ @Scheduled(fixedRate = 120000) public void updateProductStock() { // Update stock for sample products String[] productIds = {"prod-001", "prod-002", "prod-003", "prod-004", "prod-005"}; for (String productId : productIds) { int stock = random.nextInt(100) + 10; // 10-109 in stock businessMetrics.setProductStock(productId, stock); } } /** * Clean up old metrics every 10 minutes */ @Scheduled(fixedRate = 600000) public void cleanupOldMetrics() { // In a real application, you might want to clean up old gauges // or perform other maintenance tasks } }

Custom Health Indicators

Database Health Indicator

package com.example.prometheus.health; import org.springframework.boot.actuate.health.Health; import org.springframework.boot.actuate.health.HealthIndicator; import org.springframework.stereotype.Component; import java.sql.Connection; import java.sql.DriverManager; import java.util.Random; @Component public class DatabaseHealthIndicator implements HealthIndicator { private final Random random = new Random(); @Override public Health health() { try { // Simulate database health check boolean isHealthy = random.nextDouble() > 0.1; // 90% healthy if (isHealthy) { return Health.up() .withDetail("database", "H2") .withDetail("status", "connected") .withDetail("response_time", random.nextInt(50) + 10 + "ms") .build(); } else { return Health.down() .withDetail("database", "H2") .withDetail("status", "disconnected") .withDetail("error", "Connection timeout") .build(); } } catch (Exception e) { return Health.down(e).build(); } } }

Custom Business Health Indicator

package com.example.prometheus.health; import org.springframework.boot.actuate.health.Health; import org.springframework.boot.actuate.health.HealthIndicator; import org.springframework.stereotype.Component; import java.util.Random; @Component public class BusinessServiceHealthIndicator implements HealthIndicator { private final Random random = new Random(); @Override public Health health() { try { // Simulate various business service health checks boolean orderServiceHealthy = random.nextDouble() > 0.05; // 95% healthy boolean paymentServiceHealthy = random.nextDouble() > 0.02; // 98% healthy boolean inventoryServiceHealthy = random.nextDouble() > 0.08; // 92% healthy Health.Builder healthBuilder; if (orderServiceHealthy && paymentServiceHealthy && inventoryServiceHealthy) { healthBuilder = Health.up(); } else { healthBuilder = Health.down(); } return healthBuilder .withDetail("order_service", orderServiceHealthy ? "UP" : "DOWN") .withDetail("payment_service", paymentServiceHealthy ? "UP" : "DOWN") .withDetail("inventory_service", inventoryServiceHealthy ? "UP" : "DOWN") .withDetail("timestamp", System.currentTimeMillis()) .build(); } catch (Exception e) { return Health.down(e).build(); } } }

Prometheus Configuration

prometheus.yml

# prometheus.yml global: scrape_interval: 15s evaluation_interval: 15s rule_files: # - "first_rules.yml" # - "second_rules.yml" scrape_configs: - job_name: 'prometheus' static_configs: - targets: ['localhost:9090'] - job_name: 'spring-boot-app' metrics_path: '/actuator/prometheus' scrape_interval: 10s scrape_timeout: 5s static_configs: - targets: ['localhost:8081'] labels: application: 'prometheus-exporter-demo' environment: 'development' instance: 'app-instance-1' - job_name: 'spring-boot-app-business' metrics_path: '/actuator/prometheus' scrape_interval: 5s static_configs: - targets: ['localhost:8081'] metric_relabel_configs: - source_labels: [__name__] regex: '(orders_.*|revenue_.*|users_.*)' action: keep - job_name: 'spring-boot-app-system' metrics_path: '/actuator/prometheus' scrape_interval: 30s static_configs: - targets: ['localhost:8081'] metric_relabel_configs: - source_labels: [__name__] regex: '(jvm_.*|system_.*|process_.*)' action: keep alerting: alertmanagers: - static_configs: - targets: # - alertmanager:9093

Alert Rules (Optional)

# alerts.yml groups: - name: spring-boot-app-alerts rules: - alert: HighErrorRate expr: rate(orders_failed_total[5m]) > 0.1 for: 2m labels: severity: warning annotations: summary: "High order failure rate" description: "Order failure rate is {{ $value }} per second" - alert: ServiceDown expr: up{job="spring-boot-app"} == 0 for: 1m labels: severity: critical annotations: summary: "Service {{ $labels.instance }} is down" description: "Service has been down for more than 1 minute." - alert: HighMemoryUsage expr: (jvm_memory_used_bytes / jvm_memory_max_bytes) > 0.8 for: 5m labels: severity: warning annotations: summary: "High memory usage on {{ $labels.instance }}" description: "Memory usage is at {{ $value | humanizePercentage }}" - alert: SlowDatabaseQueries expr: rate(db_queries_slow_total[5m]) > 0.5 for: 2m labels: severity: warning annotations: summary: "High number of slow database queries" description: "Slow query rate is {{ $value }} per second"

Testing the Exporter

Test Controller

package com.example.prometheus.controller; import com.example.prometheus.metrics.BusinessMetricsExporter; import com.example.prometheus.metrics.DatabaseMetricsExporter; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.HashMap; import java.util.Map; @RestController @RequestMapping("/api/test") public class TestController { @Autowired private BusinessMetricsExporter businessMetrics; @Autowired private DatabaseMetricsExporter databaseMetrics; @PostMapping("/metrics/order") public Map<String, Object> testOrderMetrics() { businessMetrics.incrementOrdersCreated("test"); businessMetrics.addRevenue(99.99); businessMetrics.incrementActiveUsers(); Map<String, Object> response = new HashMap<>(); response.put("status", "metrics updated"); response.put("action", "order_created"); return response; } @PostMapping("/metrics/error") public Map<String, Object> testErrorMetrics() { businessMetrics.incrementOrdersFailed("test_error"); databaseMetrics.recordFailedQuery("SELECT", "test_table", "test_error"); Map<String, Object> response = new HashMap<>(); response.put("status", "error metrics updated"); response.put("action", "error_simulated"); return response; } @PostMapping("/metrics/database") public Map<String, Object> testDatabaseMetrics() { databaseMetrics.incrementActiveConnections(); databaseMetrics.recordQuery("SELECT", "users", 45, java.util.concurrent.TimeUnit.MILLISECONDS); databaseMetrics.recordSlowQuery("UPDATE", "orders", 100); Map<String, Object> response = new HashMap<>(); response.put("status", "database metrics updated"); response.put("action", "database_operations"); return response; } @GetMapping("/metrics/status") public Map<String, Object> getMetricsStatus() { Map<String, Object> status = new HashMap<>(); status.put("application", "prometheus-exporter-demo"); status.put("status", "running"); status.put("timestamp", System.currentTimeMillis()); status.put("endpoints", new String[] { "/actuator/prometheus", "/actuator/health", "/actuator/metrics" }); return status; } }

Integration Test

package com.example.prometheus; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.web.servlet.MockMvc; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*; @SpringBootTest @AutoConfigureMockMvc class PrometheusExporterApplicationTests { @Autowired private MockMvc mockMvc; @Test void testPrometheusEndpoint() throws Exception { mockMvc.perform(get("/actuator/prometheus")) .andExpect(status().isOk()) .andExpect(content().contentType("text/plain;version=0.0.4;charset=utf-8")) .andExpect(content().string(org.hamcrest.Matchers.containsString("jvm_memory_used_bytes"))); } @Test void testHealthEndpoint() throws Exception { mockMvc.perform(get("/actuator/health")) .andExpect(status().isOk()) .andExpect(jsonPath("$.status").exists()); } @Test void testMetricsEndpoint() throws Exception { mockMvc.perform(get("/actuator/metrics")) .andExpect(status().isOk()) .andExpect(jsonPath("$.names").isArray()); } }

Usage Examples

Accessing Metrics

# View all metrics in Prometheus format curl http://localhost:8081/actuator/prometheus # View specific metric curl http://localhost:8081/actuator/metrics/orders.created # View health status curl http://localhost:8081/actuator/health # View metrics names curl http://localhost:8081/actuator/metrics

Sample Queries for Prometheus

# Total orders created sum(orders_created_total) # Order creation rate per minute rate(orders_created_total[1m]) # Error rate percentage (rate(orders_failed_total[5m]) / rate(orders_created_total[5m])) * 100 # 95th percentile of order processing time histogram_quantile(0.95, rate(orders_processing_time_seconds_bucket[5m])) # Memory usage percentage (jvm_memory_used_bytes / jvm_memory_max_bytes) * 100 # Active database connections db_connections_active # Slow query rate rate(db_queries_slow_total[5m])

This comprehensive Prometheus exporter implementation provides robust monitoring capabilities for Spring Boot applications, including business metrics, system metrics, database metrics, and custom health checks. The solution is production-ready and can be easily extended for specific monitoring requirements.