google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
Error Budgets and SLOs in Java Applications
awiskar acharya
November 19, 2025
10:08 am

Comprehensive Implementation Guide

1. Core SLO Configuration Classes

// SLOConfig.java package com.example.slo.config; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; import java.time.Duration; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @Component @ConfigurationProperties(prefix = "slo") public class SLOConfig { private Map<String, ServiceLevelObjective> objectives = new ConcurrentHashMap<>(); private AlertingConfig alerting = new AlertingConfig(); private ExportConfig export = new ExportConfig(); public ServiceLevelObjective getObjective(String serviceName) { return objectives.get(serviceName); } public void addObjective(String serviceName, ServiceLevelObjective objective) { objectives.put(serviceName, objective); } // Getters and setters public Map<String, ServiceLevelObjective> getObjectives() { return objectives; } public void setObjectives(Map<String, ServiceLevelObjective> objectives) { this.objectives = objectives; } public AlertingConfig getAlerting() { return alerting; } public void setAlerting(AlertingConfig alerting) { this.alerting = alerting; } public ExportConfig getExport() { return export; } public void setExport(ExportConfig export) { this.export = export; } public static class ServiceLevelObjective { private String name; private String description; private double target; // e.g., 0.999 for 99.9% private Duration measurementWindow = Duration.ofDays(30); private Duration rollingWindow = Duration.ofHours(1); private Map<String, String> labels = new ConcurrentHashMap<>(); private BurnRateConfig burnRate = new BurnRateConfig(); public double getErrorBudget() { return 1.0 - target; } // Getters and setters public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public double getTarget() { return target; } public void setTarget(double target) { this.target = target; } public Duration getMeasurementWindow() { return measurementWindow; } public void setMeasurementWindow(Duration measurementWindow) { this.measurementWindow = measurementWindow; } public Duration getRollingWindow() { return rollingWindow; } public void setRollingWindow(Duration rollingWindow) { this.rollingWindow = rollingWindow; } public Map<String, String> getLabels() { return labels; } public void setLabels(Map<String, String> labels) { this.labels = labels; } public BurnRateConfig getBurnRate() { return burnRate; } public void setBurnRate(BurnRateConfig burnRate) { this.burnRate = burnRate; } } public static class BurnRateConfig { private double warningThreshold = 0.5; // 50% budget consumed private double criticalThreshold = 0.8; // 80% budget consumed private double emergencyThreshold = 0.95; // 95% budget consumed private Duration shortWindow = Duration.ofHours(1); private Duration longWindow = Duration.ofHours(6); // Getters and setters public double getWarningThreshold() { return warningThreshold; } public void setWarningThreshold(double warningThreshold) { this.warningThreshold = warningThreshold; } public double getCriticalThreshold() { return criticalThreshold; } public void setCriticalThreshold(double criticalThreshold) { this.criticalThreshold = criticalThreshold; } public double getEmergencyThreshold() { return emergencyThreshold; } public void setEmergencyThreshold(double emergencyThreshold) { this.emergencyThreshold = emergencyThreshold; } public Duration getShortWindow() { return shortWindow; } public void setShortWindow(Duration shortWindow) { this.shortWindow = shortWindow; } public Duration getLongWindow() { return longWindow; } public void setLongWindow(Duration longWindow) { this.longWindow = longWindow; } } public static class AlertingConfig { private boolean enabled = true; private String webhookUrl; private Duration evaluationInterval = Duration.ofMinutes(1); private Map<String, String> alertLabels = new ConcurrentHashMap<>(); // Getters and setters public boolean isEnabled() { return enabled; } public void setEnabled(boolean enabled) { this.enabled = enabled; } public String getWebhookUrl() { return webhookUrl; } public void setWebhookUrl(String webhookUrl) { this.webhookUrl = webhookUrl; } public Duration getEvaluationInterval() { return evaluationInterval; } public void setEvaluationInterval(Duration evaluationInterval) { this.evaluationInterval = evaluationInterval; } public Map<String, String> getAlertLabels() { return alertLabels; } public void setAlertLabels(Map<String, String> alertLabels) { this.alertLabels = alertLabels; } } public static class ExportConfig { private boolean prometheusEnabled = true; private String prometheusJobName = "slo-monitor"; private boolean metricsEnabled = true; private Duration exportInterval = Duration.ofMinutes(1); // Getters and setters public boolean isPrometheusEnabled() { return prometheusEnabled; } public void setPrometheusEnabled(boolean prometheusEnabled) { this.prometheusEnabled = prometheusEnabled; } public String getPrometheusJobName() { return prometheusJobName; } public void setPrometheusJobName(String prometheusJobName) { this.prometheusJobName = prometheusJobName; } public boolean isMetricsEnabled() { return metricsEnabled; } public void setMetricsEnabled(boolean metricsEnabled) { this.metricsEnabled = metricsEnabled; } public Duration getExportInterval() { return exportInterval; } public void setExportInterval(Duration exportInterval) { this.exportInterval = exportInterval; } } }

2. SLO Tracker and Metrics Collector

// SLOTracker.java package com.example.slo.core; import com.example.slo.config.SLOConfig; 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.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import java.time.Instant; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; @Component public class SLOTracker { private static final Logger logger = LoggerFactory.getLogger(SLOTracker.class); private final SLOConfig sloConfig; private final MeterRegistry meterRegistry; private final Map<String, ServiceTracker> serviceTrackers = new ConcurrentHashMap<>(); public SLOTracker(SLOConfig sloConfig, MeterRegistry meterRegistry) { this.sloConfig = sloConfig; this.meterRegistry = meterRegistry; initializeTrackers(); } private void initializeTrackers() { sloConfig.getObjectives().forEach((serviceName, objective) -> { ServiceTracker tracker = new ServiceTracker(serviceName, objective, meterRegistry); serviceTrackers.put(serviceName, tracker); logger.info("Initialized SLO tracker for service: {}", serviceName); }); } public void recordSuccess(String serviceName) { ServiceTracker tracker = serviceTrackers.get(serviceName); if (tracker != null) { tracker.recordSuccess(); } else { logger.warn("No SLO tracker found for service: {}", serviceName); } } public void recordError(String serviceName, String errorType) { ServiceTracker tracker = serviceTrackers.get(serviceName); if (tracker != null) { tracker.recordError(errorType); } else { logger.warn("No SLO tracker found for service: {}", serviceName); } } public void recordLatency(String serviceName, long durationMs) { ServiceTracker tracker = serviceTrackers.get(serviceName); if (tracker != null) { tracker.recordLatency(durationMs); } } public SLOStatus getCurrentStatus(String serviceName) { ServiceTracker tracker = serviceTrackers.get(serviceName); return tracker != null ? tracker.getCurrentStatus() : null; } public Map<String, SLOStatus> getAllStatuses() { Map<String, SLOStatus> statuses = new ConcurrentHashMap<>(); serviceTrackers.forEach((serviceName, tracker) -> { statuses.put(serviceName, tracker.getCurrentStatus()); }); return statuses; } @Scheduled(fixedRateString = "${slo.export.interval:60000}") public void exportMetrics() { if (sloConfig.getExport().isMetricsEnabled()) { serviceTrackers.values().forEach(ServiceTracker::exportMetrics); } } public static class ServiceTracker { private final String serviceName; private final SLOConfig.ServiceLevelObjective objective; private final MeterRegistry meterRegistry; private final AtomicLong totalRequests = new AtomicLong(0); private final AtomicLong successfulRequests = new AtomicLong(0); private final AtomicLong errorRequests = new AtomicLong(0); private final AtomicReference<Instant> windowStartTime = new AtomicReference<>(Instant.now()); private final Map<String, AtomicLong> errorCountsByType = new ConcurrentHashMap<>(); // Micrometer metrics private final Counter successCounter; private final Counter errorCounter; private final Timer latencyTimer; private final Gauge errorBudgetGauge; private final Gauge burnRateGauge; public ServiceTracker(String serviceName, SLOConfig.ServiceLevelObjective objective, MeterRegistry meterRegistry) { this.serviceName = serviceName; this.objective = objective; this.meterRegistry = meterRegistry; // Initialize metrics this.successCounter = Counter.builder("slo.requests.total") .tag("service", serviceName) .tag("status", "success") .register(meterRegistry); this.errorCounter = Counter.builder("slo.requests.total") .tag("service", serviceName) .tag("status", "error") .register(meterRegistry); this.latencyTimer = Timer.builder("slo.request.duration") .tag("service", serviceName) .register(meterRegistry); this.errorBudgetGauge = Gauge.builder("slo.error_budget.remaining") .tag("service", serviceName) .register(meterRegistry, this, tracker -> tracker.getCurrentStatus().getRemainingErrorBudget()); this.burnRateGauge = Gauge.builder("slo.burn_rate") .tag("service", serviceName) .register(meterRegistry, this, tracker -> tracker.getCurrentStatus().getBurnRate()); } public void recordSuccess() { totalRequests.incrementAndGet(); successfulRequests.incrementAndGet(); successCounter.increment(); resetWindowIfNeeded(); } public void recordError(String errorType) { totalRequests.incrementAndGet(); errorRequests.incrementAndGet(); errorCounter.increment(); errorCountsByType.computeIfAbsent(errorType, k -> new AtomicLong(0)).incrementAndGet(); resetWindowIfNeeded(); } public void recordLatency(long durationMs) { latencyTimer.record(java.time.Duration.ofMillis(durationMs)); } public SLOStatus getCurrentStatus() { resetWindowIfNeeded(); long total = totalRequests.get(); long errors = errorRequests.get(); long successes = successfulRequests.get(); if (total == 0) { return new SLOStatus(serviceName, objective, 1.0, 0.0, 0.0, objective.getErrorBudget(), objective.getErrorBudget(), 0.0, Instant.now()); } double actualAvailability = (double) successes / total; double errorRate = (double) errors / total; double consumedBudget = errorRate; double remainingBudget = Math.max(0, objective.getErrorBudget() - consumedBudget); double burnRate = calculateBurnRate(); return new SLOStatus(serviceName, objective, actualAvailability, errorRate, consumedBudget, objective.getErrorBudget(), remainingBudget, burnRate, Instant.now()); } private double calculateBurnRate() { long totalInWindow = totalRequests.get(); if (totalInWindow == 0) return 0.0; double expectedRequestsPerWindow = getExpectedRequestsPerWindow(); if (expectedRequestsPerWindow == 0) return 0.0; double actualErrorRate = (double) errorRequests.get() / totalInWindow; double expectedErrorRate = objective.getErrorBudget(); return actualErrorRate / expectedErrorRate; } private double getExpectedRequestsPerWindow() { // This is a simplified calculation - in production, you'd want // to use historical data or configuration Duration windowDuration = objective.getRollingWindow(); return 1000.0; // Example baseline } private void resetWindowIfNeeded() { Instant now = Instant.now(); Instant windowStart = windowStartTime.get(); Duration windowDuration = objective.getRollingWindow(); if (windowStart.plus(windowDuration).isBefore(now)) { if (windowStartTime.compareAndSet(windowStart, now)) { // Reset counters for new window totalRequests.set(0); successfulRequests.set(0); errorRequests.set(0); errorCountsByType.clear(); logger.debug("Reset SLO tracking window for service: {}", serviceName); } } } public void exportMetrics() { SLOStatus status = getCurrentStatus(); // Export additional metrics Gauge.builder("slo.availability.current") .tag("service", serviceName) .register(meterRegistry, status, SLOStatus::getActualAvailability); Gauge.builder("slo.error_rate.current") .tag("service", serviceName) .register(meterRegistry, status, SLOStatus::getErrorRate); } } public static class SLOStatus { private final String serviceName; private final SLOConfig.ServiceLevelObjective objective; private final double actualAvailability; private final double errorRate; private final double consumedErrorBudget; private final double totalErrorBudget; private final double remainingErrorBudget; private final double burnRate; private final Instant timestamp; public SLOStatus(String serviceName, SLOConfig.ServiceLevelObjective objective, double actualAvailability, double errorRate, double consumedErrorBudget, double totalErrorBudget, double remainingErrorBudget, double burnRate, Instant timestamp) { this.serviceName = serviceName; this.objective = objective; this.actualAvailability = actualAvailability; this.errorRate = errorRate; this.consumedErrorBudget = consumedErrorBudget; this.totalErrorBudget = totalErrorBudget; this.remainingErrorBudget = remainingErrorBudget; this.burnRate = burnRate; this.timestamp = timestamp; } public boolean isWithinSLO() { return actualAvailability >= (1.0 - totalErrorBudget); } public AlertLevel getAlertLevel() { double budgetConsumptionRatio = consumedErrorBudget / totalErrorBudget; if (budgetConsumptionRatio >= objective.getBurnRate().getEmergencyThreshold()) { return AlertLevel.EMERGENCY; } else if (budgetConsumptionRatio >= objective.getBurnRate().getCriticalThreshold()) { return AlertLevel.CRITICAL; } else if (budgetConsumptionRatio >= objective.getBurnRate().getWarningThreshold()) { return AlertLevel.WARNING; } else { return AlertLevel.NORMAL; } } // Getters public String getServiceName() { return serviceName; } public double getActualAvailability() { return actualAvailability; } public double getErrorRate() { return errorRate; } public double getConsumedErrorBudget() { return consumedErrorBudget; } public double getTotalErrorBudget() { return totalErrorBudget; } public double getRemainingErrorBudget() { return remainingErrorBudget; } public double getBurnRate() { return burnRate; } public Instant getTimestamp() { return timestamp; } public SLOConfig.ServiceLevelObjective getObjective() { return objective; } @Override public String toString() { return String.format( "SLOStatus{service=%s, availability=%.4f, errorRate=%.4f, remainingBudget=%.4f, burnRate=%.2f}", serviceName, actualAvailability, errorRate, remainingErrorBudget, burnRate); } } public enum AlertLevel { NORMAL, WARNING, CRITICAL, EMERGENCY } }

3. SLO Alert Manager

// SLOAlertManager.java package com.example.slo.alert; import com.example.slo.core.SLOTracker; import com.example.slo.config.SLOConfig; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @Component public class SLOAlertManager { private static final Logger logger = LoggerFactory.getLogger(SLOAlertManager.class); private final SLOTracker sloTracker; private final SLOConfig sloConfig; private final AlertNotifier alertNotifier; private final Map<String, SLOTracker.AlertLevel> lastAlertLevels = new ConcurrentHashMap<>(); public SLOAlertManager(SLOTracker sloTracker, SLOConfig sloConfig, AlertNotifier alertNotifier) { this.sloTracker = sloTracker; this.sloConfig = sloConfig; this.alertNotifier = alertNotifier; } @Scheduled(fixedRateString = "${slo.alerting.evaluation-interval:60000}") public void evaluateSLOAlerts() { if (!sloConfig.getAlerting().isEnabled()) { return; } Map<String, SLOTracker.SLOStatus> statuses = sloTracker.getAllStatuses(); for (Map.Entry<String, SLOTracker.SLOStatus> entry : statuses.entrySet()) { String serviceName = entry.getKey(); SLOTracker.SLOStatus status = entry.getValue(); SLOTracker.AlertLevel currentLevel = status.getAlertLevel(); SLOTracker.AlertLevel lastLevel = lastAlertLevels.get(serviceName); // Check if alert level changed if (lastLevel == null || currentLevel != lastLevel) { handleAlertLevelChange(serviceName, status, currentLevel, lastLevel); lastAlertLevels.put(serviceName, currentLevel); } // Send ongoing alert if not normal if (currentLevel != SLOTracker.AlertLevel.NORMAL) { sendOngoingAlert(serviceName, status, currentLevel); } } } private void handleAlertLevelChange(String serviceName, SLOTracker.SLOStatus status, SLOTracker.AlertLevel currentLevel, SLOTracker.AlertLevel lastLevel) { String message = buildAlertMessage(serviceName, status, currentLevel, lastLevel); switch (currentLevel) { case EMERGENCY: alertNotifier.sendEmergencyAlert(serviceName, message, status); triggerEmergencyActions(serviceName, status); break; case CRITICAL: alertNotifier.sendCriticalAlert(serviceName, message, status); triggerCriticalActions(serviceName, status); break; case WARNING: alertNotifier.sendWarningAlert(serviceName, message, status); break; case NORMAL: if (lastLevel != null && lastLevel != SLOTracker.AlertLevel.NORMAL) { alertNotifier.sendRecoveryAlert(serviceName, String.format("SLO recovered for service %s. Current availability: %.4f", serviceName, status.getActualAvailability()), status); } break; } logger.info("SLO Alert Level Changed - Service: {}, From: {}, To: {}, Message: {}", serviceName, lastLevel, currentLevel, message); } private void sendOngoingAlert(String serviceName, SLOTracker.SLOStatus status, SLOTracker.AlertLevel level) { String message = String.format( "Ongoing SLO alert for service %s. Availability: %.4f, Error Budget Remaining: %.4f, Burn Rate: %.2f", serviceName, status.getActualAvailability(), status.getRemainingErrorBudget(), status.getBurnRate()); alertNotifier.sendOngoingAlert(serviceName, message, status, level); } private String buildAlertMessage(String serviceName, SLOTracker.SLOStatus status, SLOTracker.AlertLevel currentLevel, SLOTracker.AlertLevel lastLevel) { return String.format( "SLO Alert for service %s - Level: %s -> %s | " + "Availability: %.4f (target: %.4f) | " + "Error Budget Remaining: %.4f | Burn Rate: %.2f", serviceName, lastLevel, currentLevel, status.getActualAvailability(), (1 - status.getTotalErrorBudget()), status.getRemainingErrorBudget(), status.getBurnRate()); } private void triggerEmergencyActions(String serviceName, SLOTracker.SLOStatus status) { logger.warn("Triggering emergency actions for service: {}", serviceName); // Implement emergency actions: // - Page on-call engineer // - Scale up resources // - Enable circuit breakers // - Disable non-critical features } private void triggerCriticalActions(String serviceName, SLOTracker.SLOStatus status) { logger.warn("Triggering critical actions for service: {}", serviceName); // Implement critical actions: // - Notify engineering team // - Increase monitoring frequency // - Prepare rollback procedures } }

4. Alert Notifier Implementation

// AlertNotifier.java package com.example.slo.alert; import com.example.slo.core.SLOTracker; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.http.*; import org.springframework.stereotype.Component; import org.springframework.web.client.RestTemplate; import java.util.HashMap; import java.util.Map; @Component public class AlertNotifier { private static final Logger logger = LoggerFactory.getLogger(AlertNotifier.class); private final RestTemplate restTemplate; private final String webhookUrl; public AlertNotifier(RestTemplate restTemplate, String webhookUrl) { this.restTemplate = restTemplate; this.webhookUrl = webhookUrl; } public void sendEmergencyAlert(String serviceName, String message, SLOTracker.SLOStatus status) { Map<String, Object> alertPayload = createAlertPayload("EMERGENCY", serviceName, message, status); sendWebhookAlert(alertPayload); logger.error("EMERGENCY SLO ALERT - Service: {}, Message: {}", serviceName, message); } public void sendCriticalAlert(String serviceName, String message, SLOTracker.SLOStatus status) { Map<String, Object> alertPayload = createAlertPayload("CRITICAL", serviceName, message, status); sendWebhookAlert(alertPayload); logger.error("CRITICAL SLO ALERT - Service: {}, Message: {}", serviceName, message); } public void sendWarningAlert(String serviceName, String message, SLOTracker.SLOStatus status) { Map<String, Object> alertPayload = createAlertPayload("WARNING", serviceName, message, status); sendWebhookAlert(alertPayload); logger.warn("WARNING SLO ALERT - Service: {}, Message: {}", serviceName, message); } public void sendRecoveryAlert(String serviceName, String message, SLOTracker.SLOStatus status) { Map<String, Object> alertPayload = createAlertPayload("RECOVERY", serviceName, message, status); sendWebhookAlert(alertPayload); logger.info("SLO RECOVERY - Service: {}, Message: {}", serviceName, message); } public void sendOngoingAlert(String serviceName, String message, SLOTracker.SLOStatus status, SLOTracker.AlertLevel level) { Map<String, Object> alertPayload = createAlertPayload(level.name(), serviceName, message, status); sendWebhookAlert(alertPayload); } private Map<String, Object> createAlertPayload(String severity, String serviceName, String message, SLOTracker.SLOStatus status) { Map<String, Object> payload = new HashMap<>(); payload.put("severity", severity); payload.put("service", serviceName); payload.put("message", message); payload.put("timestamp", status.getTimestamp().toString()); Map<String, Object> metrics = new HashMap<>(); metrics.put("availability", status.getActualAvailability()); metrics.put("error_rate", status.getErrorRate()); metrics.put("error_budget_remaining", status.getRemainingErrorBudget()); metrics.put("burn_rate", status.getBurnRate()); metrics.put("slo_target", 1 - status.getTotalErrorBudget()); payload.put("metrics", metrics); payload.put("labels", status.getObjective().getLabels()); return payload; } private void sendWebhookAlert(Map<String, Object> payload) { if (webhookUrl == null || webhookUrl.isEmpty()) { logger.debug("No webhook URL configured, skipping alert notification"); return; } try { HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity<Map<String, Object>> request = new HttpEntity<>(payload, headers); ResponseEntity<String> response = restTemplate.exchange( webhookUrl, HttpMethod.POST, request, String.class); if (response.getStatusCode().is2xxSuccessful()) { logger.debug("Alert notification sent successfully"); } else { logger.warn("Failed to send alert notification: {}", response.getStatusCode()); } } catch (Exception e) { logger.error("Failed to send alert notification to webhook", e); } } }

5. Spring Boot Auto-Configuration

// SLOAutoConfiguration.java package com.example.slo.config; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.web.client.RestTemplateBuilder; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.client.RestTemplate; @Configuration public class SLOAutoConfiguration { @Bean @ConditionalOnMissingBean public SLOConfig sloConfig() { return new SLOConfig(); } @Bean @ConditionalOnMissingBean public RestTemplate restTemplate(RestTemplateBuilder builder) { return builder.build(); } }

6. Aspect-Oriented SLO Monitoring

// SLOMonitoringAspect.java package com.example.slo.aspect; import com.example.slo.core.SLOTracker; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.reflect.MethodSignature; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; import java.lang.reflect.Method; @Aspect @Component public class SLOMonitoringAspect { private static final Logger logger = LoggerFactory.getLogger(SLOMonitoringAspect.class); private final SLOTracker sloTracker; public SLOMonitoringAspect(SLOTracker sloTracker) { this.sloTracker = sloTracker; } @Around("@annotation(MonitorSLO)") public Object monitorSLO(ProceedingJoinPoint joinPoint) throws Throwable { Method method = ((MethodSignature) joinPoint.getSignature()).getMethod(); MonitorSLO annotation = method.getAnnotation(MonitorSLO.class); String serviceName = annotation.service(); long startTime = System.currentTimeMillis(); boolean success = false; try { Object result = joinPoint.proceed(); success = true; return result; } catch (Exception e) { sloTracker.recordError(serviceName, e.getClass().getSimpleName()); logger.debug("Recorded error for service {}: {}", serviceName, e.getMessage()); throw e; } finally { long duration = System.currentTimeMillis() - startTime; if (success) { sloTracker.recordSuccess(serviceName); } sloTracker.recordLatency(serviceName, duration); logger.debug("SLO monitoring - Service: {}, Success: {}, Duration: {}ms", serviceName, success, duration); } } } // MonitorSLO Annotation package com.example.slo.aspect; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface MonitorSLO { String service(); String operation() default ""; }

7. REST Controller for SLO Management

// SLOController.java package com.example.slo.controller; import com.example.slo.core.SLOTracker; import com.example.slo.config.SLOConfig; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.util.Map; @RestController @RequestMapping("/api/slo") public class SLOController { private final SLOTracker sloTracker; private final SLOConfig sloConfig; public SLOController(SLOTracker sloTracker, SLOConfig sloConfig) { this.sloTracker = sloTracker; this.sloConfig = sloConfig; } @GetMapping("/status") public ResponseEntity<Map<String, SLOTracker.SLOStatus>> getAllStatuses() { return ResponseEntity.ok(sloTracker.getAllStatuses()); } @GetMapping("/status/{serviceName}") public ResponseEntity<SLOTracker.SLOStatus> getServiceStatus(@PathVariable String serviceName) { SLOTracker.SLOStatus status = sloTracker.getCurrentStatus(serviceName); if (status == null) { return ResponseEntity.notFound().build(); } return ResponseEntity.ok(status); } @GetMapping("/config") public ResponseEntity<SLOConfig> getConfig() { return ResponseEntity.ok(sloConfig); } @PostMapping("/record/success/{serviceName}") public ResponseEntity<Void> recordSuccess(@PathVariable String serviceName) { sloTracker.recordSuccess(serviceName); return ResponseEntity.accepted().build(); } @PostMapping("/record/error/{serviceName}") public ResponseEntity<Void> recordError(@PathVariable String serviceName, @RequestParam String errorType) { sloTracker.recordError(serviceName, errorType); return ResponseEntity.accepted().build(); } @GetMapping("/health") public ResponseEntity<Map<String, Object>> getHealth() { Map<String, SLOTracker.SLOStatus> statuses = sloTracker.getAllStatuses(); long healthyServices = statuses.values().stream() .filter(SLOTracker.SLOStatus::isWithinSLO) .count(); Map<String, Object> health = Map.of( "totalServices", statuses.size(), "healthyServices", healthyServices, "unhealthyServices", statuses.size() - healthyServices, "timestamp", java.time.Instant.now() ); return ResponseEntity.ok(health); } }

8. Application Configuration

# application.yml slo: objectives: user-service: name: "User Service" description: "User management service SLO" target: 0.999 # 99.9% availability measurement-window: 30d rolling-window: 1h labels: team: "backend" criticality: "high" burn-rate: warning-threshold: 0.5 critical-threshold: 0.8 emergency-threshold: 0.95 short-window: 1h long-window: 6h payment-service: name: "Payment Service" description: "Payment processing service SLO" target: 0.9999 # 99.99% availability measurement-window: 30d rolling-window: 1h labels: team: "payments" criticality: "critical" burn-rate: warning-threshold: 0.3 critical-threshold: 0.6 emergency-threshold: 0.9 short-window: 1h long-window: 6h alerting: enabled: true webhook-url: "https://hooks.slack.com/services/your-webhook-url" evaluation-interval: 1m alert-labels: environment: "production" region: "us-east-1" export: prometheus-enabled: true prometheus-job-name: "slo-monitor" metrics-enabled: true export-interval: 1m management: endpoints: web: exposure: include: health,metrics,prometheus endpoint: metrics: enabled: true prometheus: enabled: true

9. Example Service Usage

// ExampleService.java package com.example.slo.service; import com.example.slo.aspect.MonitorSLO; import org.springframework.stereotype.Service; @Service public class ExampleService { @MonitorSLO(service = "user-service", operation = "getUser") public User getUser(String userId) { // Business logic here return new User(userId, "John Doe"); } @MonitorSLO(service = "user-service", operation = "createUser") public User createUser(User user) { // Business logic here if (user.getEmail() == null) { throw new IllegalArgumentException("Email is required"); } return user; } @MonitorSLO(service = "payment-service", operation = "processPayment") public PaymentResult processPayment(PaymentRequest request) { // Business logic here if (request.getAmount() <= 0) { throw new IllegalArgumentException("Invalid payment amount"); } return new PaymentResult("success", "Payment processed"); } // Domain classes public static class User { private String id; private String name; private String email; public User(String id, String name) { this.id = id; this.name = name; } // Getters and setters public String getId() { return id; } public String getName() { return name; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } } public static class PaymentRequest { private double amount; private String currency; // Getters and setters public double getAmount() { return amount; } public void setAmount(double amount) { this.amount = amount; } public String getCurrency() { return currency; } public void setCurrency(String currency) { this.currency = currency; } } public static class PaymentResult { private String status; private String message; public PaymentResult(String status, String message) { this.status = status; this.message = message; } // Getters public String getStatus() { return status; } public String getMessage() { return message; } } }

This comprehensive Error Budgets and SLOs implementation provides:

  • Flexible SLO configuration with multiple service support
  • Real-time metrics collection and tracking
  • Error budget calculation and burn rate monitoring
  • Multi-level alerting system with configurable thresholds
  • Aspect-oriented monitoring for easy integration
  • REST API for management and monitoring
  • Prometheus metrics export for visualization
  • Webhook integrations for alert notifications
  • Spring Boot auto-configuration

The system helps maintain service reliability while providing clear visibility into error budget consumption and SLO compliance.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper