MACRO NEPAL
Service Mesh Observability in Java
awiskar acharya
November 11, 2025
9:10 am

A comprehensive observability implementation for Java microservices in service mesh environments, providing distributed tracing, metrics collection, logging correlation, and service mesh integration.

Complete Implementation

1. Core Observability Configuration

package com.observability.mesh;
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.SpanKind;
import io.opentelemetry.context.Context;
import io.opentelemetry.context.propagation.ContextPropagators;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
import io.opentelemetry.exporter.prometheus.PrometheusHttpServer;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
import io.opentelemetry.semconv.ResourceAttributes;
import java.util.*;
import java.util.concurrent.*;
/**
* Main observability manager for service mesh environments
*/
public class ServiceMeshObservability {
private static final String INSTRUMENTATION_NAME = "service-mesh-observability";
private final OpenTelemetry openTelemetry;
private final Tracer tracer;
private final MetricsCollector metricsCollector;
private final DistributedLogger distributedLogger;
private final ServiceMeshIntegrator meshIntegrator;
private final ObservabilityConfig config;
private static volatile ServiceMeshObservability instance;
private ServiceMeshObservability(ObservabilityConfig config) {
this.config = config;
this.openTelemetry = initializeOpenTelemetry(config);
this.tracer = openTelemetry.getTracer(INSTRUMENTATION_NAME, "1.0.0");
this.metricsCollector = new MetricsCollector(openTelemetry, config);
this.distributedLogger = new DistributedLogger(openTelemetry);
this.meshIntegrator = new ServiceMeshIntegrator(config);
initializeServiceMeshIntegration();
}
public static ServiceMeshObservability initialize(ObservabilityConfig config) {
if (instance == null) {
synchronized (ServiceMeshObservability.class) {
if (instance == null) {
instance = new ServiceMeshObservability(config);
}
}
}
return instance;
}
public static ServiceMeshObservability getInstance() {
if (instance == null) {
throw new IllegalStateException("ServiceMeshObservability not initialized. Call initialize() first.");
}
return instance;
}
private OpenTelemetry initializeOpenTelemetry(ObservabilityConfig config) {
// Create resource with service attributes
Resource resource = Resource.getDefault()
.merge(Resource.create(Attributes.builder()
.put(ResourceAttributes.SERVICE_NAME, config.getServiceName())
.put(ResourceAttributes.SERVICE_VERSION, config.getServiceVersion())
.put(ResourceAttributes.DEPLOYMENT_ENVIRONMENT, config.getEnvironment())
.put("service.mesh", config.getMeshName())
.put("service.cluster", config.getClusterName())
.build()));
// Configure span exporter
OtlpGrpcSpanExporter spanExporter = OtlpGrpcSpanExporter.builder()
.setEndpoint(config.getOtlpEndpoint())
.setTimeout(config.getExportTimeout())
.build();
// Configure tracer provider
SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
.setResource(resource)
.addSpanProcessor(BatchSpanProcessor.builder(spanExporter).build())
.build();
// Configure metrics exporter
PrometheusHttpServer prometheusExporter = PrometheusHttpServer.builder()
.setPort(config.getMetricsPort())
.build();
// Build OpenTelemetry instance
return OpenTelemetrySdk.builder()
.setTracerProvider(tracerProvider)
.setPropagators(ContextPropagators.create(TextMapPropagator.composite(
W3CTraceContextPropagator.getInstance(),
W3CBaggagePropagator.getInstance()
)))
.buildAndRegisterGlobal();
}
private void initializeServiceMeshIntegration() {
meshIntegrator.initialize();
metricsCollector.registerMeshMetrics();
// Register shutdown hook
Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown));
}
/**
* Create a new span for a service operation
*/
public ObservabilityScope startOperation(String operationName, Map<String, String> attributes) {
Span span = tracer.spanBuilder(operationName)
.setSpanKind(SpanKind.SERVER)
.setAttribute("service.mesh.operation", operationName)
.setAllAttributes(Attributes.builder()
.putAll(convertToAttributes(attributes))
.build())
.startSpan();
Context context = Context.current().with(span);
return new ObservabilityScope(span, context, metricsCollector, distributedLogger, operationName);
}
/**
* Create a client span for outbound calls
*/
public ObservabilityScope startClientCall(String serviceName, String operation, Map<String, String> headers) {
Span span = tracer.spanBuilder(serviceName + "." + operation)
.setSpanKind(SpanKind.CLIENT)
.setAttribute("peer.service", serviceName)
.setAttribute("rpc.method", operation)
.setAttribute("service.mesh.direction", "outbound")
.startSpan();
// Inject headers for propagation
Map<String, String> propagationHeaders = new HashMap<>();
TextMapPropagator propagator = openTelemetry.getPropagators().getTextMapPropagator();
propagator.inject(Context.current().with(span), propagationHeaders, Map::put);
if (headers != null) {
propagationHeaders.putAll(headers);
}
Context context = Context.current().with(span);
return new ObservabilityScope(span, context, metricsCollector, distributedLogger, operation)
.withPropagationHeaders(propagationHeaders);
}
/**
* Extract context from incoming headers
*/
public Context extractContext(Map<String, String> headers) {
TextMapPropagator propagator = openTelemetry.getPropagators().getTextMapPropagator();
return propagator.extract(Context.current(), headers, (carrier, key) -> carrier.get(key.toLowerCase()));
}
/**
* Record business metrics
*/
public void recordBusinessMetric(String metricName, double value, Map<String, String> dimensions) {
metricsCollector.recordBusinessMetric(metricName, value, dimensions);
}
/**
* Record mesh-specific metrics
*/
public void recordMeshMetric(String metricName, double value, Map<String, String> meshDimensions) {
metricsCollector.recordMeshMetric(metricName, value, meshDimensions);
}
/**
* Log with distributed context
*/
public void logWithContext(String level, String message, Map<String, Object> fields) {
distributedLogger.log(level, message, fields);
}
/**
* Get service mesh insights
*/
public ServiceMeshInsights getMeshInsights() {
return meshIntegrator.collectInsights();
}
/**
* Check service mesh health
*/
public ServiceMeshHealth getMeshHealth() {
return meshIntegrator.checkHealth();
}
private Attributes convertToAttributes(Map<String, String> map) {
if (map == null || map.isEmpty()) {
return Attributes.empty();
}
Attributes.Builder builder = Attributes.builder();
for (Map.Entry<String, String> entry : map.entrySet()) {
builder.put(entry.getKey(), entry.getValue());
}
return builder.build();
}
private void shutdown() {
metricsCollector.shutdown();
meshIntegrator.shutdown();
System.info("Service mesh observability shutdown completed");
}
// Getters
public OpenTelemetry getOpenTelemetry() { return openTelemetry; }
public Tracer getTracer() { return tracer; }
public MetricsCollector getMetricsCollector() { return metricsCollector; }
public DistributedLogger getDistributedLogger() { return distributedLogger; }
public ServiceMeshIntegrator getMeshIntegrator() { return meshIntegrator; }
}

2. Observability Configuration

/**
* Observability configuration
*/
public class ObservabilityConfig {
private final String serviceName;
private final String serviceVersion;
private final String environment;
private final String meshName;
private final String clusterName;
private final String otlpEndpoint;
private final int metricsPort;
private final Duration exportTimeout;
private final boolean enableTracing;
private final boolean enableMetrics;
private final boolean enableLogging;
private final Map<String, String> customAttributes;
private ObservabilityConfig(Builder builder) {
this.serviceName = builder.serviceName;
this.serviceVersion = builder.serviceVersion;
this.environment = builder.environment;
this.meshName = builder.meshName;
this.clusterName = builder.clusterName;
this.otlpEndpoint = builder.otlpEndpoint;
this.metricsPort = builder.metricsPort;
this.exportTimeout = builder.exportTimeout;
this.enableTracing = builder.enableTracing;
this.enableMetrics = builder.enableMetrics;
this.enableLogging = builder.enableLogging;
this.customAttributes = builder.customAttributes;
}
// Getters
public String getServiceName() { return serviceName; }
public String getServiceVersion() { return serviceVersion; }
public String getEnvironment() { return environment; }
public String getMeshName() { return meshName; }
public String getClusterName() { return clusterName; }
public String getOtlpEndpoint() { return otlpEndpoint; }
public int getMetricsPort() { return metricsPort; }
public Duration getExportTimeout() { return exportTimeout; }
public boolean isEnableTracing() { return enableTracing; }
public boolean isEnableMetrics() { return enableMetrics; }
public boolean isEnableLogging() { return enableLogging; }
public Map<String, String> getCustomAttributes() { return customAttributes; }
public static Builder builder() {
return new Builder();
}
public static class Builder {
private String serviceName = "unknown-service";
private String serviceVersion = "1.0.0";
private String environment = "development";
private String meshName = "istio";
private String clusterName = "default";
private String otlpEndpoint = "http://localhost:4317";
private int metricsPort = 9464;
private Duration exportTimeout = Duration.ofSeconds(30);
private boolean enableTracing = true;
private boolean enableMetrics = true;
private boolean enableLogging = true;
private Map<String, String> customAttributes = new HashMap<>();
public Builder serviceName(String serviceName) {
this.serviceName = serviceName;
return this;
}
public Builder serviceVersion(String serviceVersion) {
this.serviceVersion = serviceVersion;
return this;
}
public Builder environment(String environment) {
this.environment = environment;
return this;
}
public Builder meshName(String meshName) {
this.meshName = meshName;
return this;
}
public Builder clusterName(String clusterName) {
this.clusterName = clusterName;
return this;
}
public Builder otlpEndpoint(String otlpEndpoint) {
this.otlpEndpoint = otlpEndpoint;
return this;
}
public Builder metricsPort(int metricsPort) {
this.metricsPort = metricsPort;
return this;
}
public Builder exportTimeout(Duration exportTimeout) {
this.exportTimeout = exportTimeout;
return this;
}
public Builder enableTracing(boolean enableTracing) {
this.enableTracing = enableTracing;
return this;
}
public Builder enableMetrics(boolean enableMetrics) {
this.enableMetrics = enableMetrics;
return this;
}
public Builder enableLogging(boolean enableLogging) {
this.enableLogging = enableLogging;
return this;
}
public Builder customAttributes(Map<String, String> customAttributes) {
this.customAttributes = customAttributes;
return this;
}
public Builder customAttribute(String key, String value) {
this.customAttributes.put(key, value);
return this;
}
public ObservabilityConfig build() {
return new ObservabilityConfig(this);
}
}
}
/**
* Observability scope for managing traces and context
*/
public class ObservabilityScope implements AutoCloseable {
private final Span span;
private final Context context;
private final MetricsCollector metricsCollector;
private final DistributedLogger logger;
private final String operationName;
private final long startTime;
private Map<String, String> propagationHeaders;
private boolean completed = false;
public ObservabilityScope(Span span, Context context, MetricsCollector metricsCollector, 
DistributedLogger logger, String operationName) {
this.span = span;
this.context = context;
this.metricsCollector = metricsCollector;
this.logger = logger;
this.operationName = operationName;
this.startTime = System.currentTimeMillis();
this.propagationHeaders = new HashMap<>();
// Make this context current
io.opentelemetry.context.Scope scope = context.makeCurrent();
// Scope should be closed by the caller when they are done with the context
}
public ObservabilityScope withPropagationHeaders(Map<String, String> headers) {
this.propagationHeaders = headers;
return this;
}
public Map<String, String> getPropagationHeaders() {
return new HashMap<>(propagationHeaders);
}
public void addEvent(String name, Map<String, String> attributes) {
span.addEvent(name, convertToAttributes(attributes));
}
public void setAttribute(String key, String value) {
span.setAttribute(key, value);
}
public void setAttributes(Map<String, String> attributes) {
for (Map.Entry<String, String> entry : attributes.entrySet()) {
span.setAttribute(entry.getKey(), entry.getValue());
}
}
public void recordMetric(String metricName, double value, Map<String, String> dimensions) {
metricsCollector.recordBusinessMetric(metricName, value, dimensions);
}
public void log(String level, String message, Map<String, Object> fields) {
logger.log(level, message, fields);
}
public void success() {
if (!completed) {
span.setAttribute("success", true);
recordLatencyMetric(true);
completed = true;
}
}
public void error(Throwable throwable) {
if (!completed) {
span.recordException(throwable);
span.setAttribute("error", true);
span.setAttribute("error.type", throwable.getClass().getSimpleName());
span.setAttribute("error.message", throwable.getMessage());
recordLatencyMetric(false);
completed = true;
}
}
public void error(String errorCode, String errorMessage) {
if (!completed) {
span.setAttribute("error", true);
span.setAttribute("error.code", errorCode);
span.setAttribute("error.message", errorMessage);
recordLatencyMetric(false);
completed = true;
}
}
@Override
public void close() {
if (!completed) {
// If not explicitly marked as success/error, assume success
success();
}
span.end();
// Record operation metrics
long duration = System.currentTimeMillis() - startTime;
metricsCollector.recordOperationMetric(operationName, duration, completed);
}
private void recordLatencyMetric(boolean success) {
long duration = System.currentTimeMillis() - startTime;
Map<String, String> dimensions = new HashMap<>();
dimensions.put("operation", operationName);
dimensions.put("success", String.valueOf(success));
metricsCollector.recordBusinessMetric("operation.latency", duration, dimensions);
}
private Attributes convertToAttributes(Map<String, String> map) {
if (map == null || map.isEmpty()) {
return Attributes.empty();
}
Attributes.Builder builder = Attributes.builder();
for (Map.Entry<String, String> entry : map.entrySet()) {
builder.put(entry.getKey(), entry.getValue());
}
return builder.build();
}
// Getters
public Span getSpan() { return span; }
public Context getContext() { return context; }
public String getOperationName() { return operationName; }
public String getTraceId() { return span.getSpanContext().getTraceId(); }
public String getSpanId() { return span.getSpanContext().getSpanId(); }
}

3. Metrics Collection

/**
* Metrics collector for service mesh observability
*/
public class MetricsCollector {
private final OpenTelemetry openTelemetry;
private final ObservabilityConfig config;
private final Map<String, io.opentelemetry.api.metrics.LongCounter> counters;
private final Map<String, io.opentelemetry.api.metrics.DoubleHistogram> histograms;
private final Map<String, io.opentelemetry.api.metrics.LongUpDownCounter> upDownCounters;
private final ScheduledExecutorService metricsExecutor;
public MetricsCollector(OpenTelemetry openTelemetry, ObservabilityConfig config) {
this.openTelemetry = openTelemetry;
this.config = config;
this.counters = new ConcurrentHashMap<>();
this.histograms = new ConcurrentHashMap<>();
this.upDownCounters = new ConcurrentHashMap<>();
this.metricsExecutor = Executors.newScheduledThreadPool(1);
initializeDefaultMetrics();
startPeriodicMetricsCollection();
}
private void initializeDefaultMetrics() {
// HTTP request metrics
createCounter("http_requests_total", "Total HTTP requests", "requests");
createHistogram("http_request_duration_seconds", "HTTP request duration in seconds", "seconds");
createCounter("http_errors_total", "Total HTTP errors", "errors");
// Business metrics
createCounter("business_operations_total", "Total business operations", "operations");
createHistogram("business_operation_duration_ms", "Business operation duration", "milliseconds");
// System metrics
createUpDownCounter("active_connections", "Active connections", "connections");
createGauge("memory_usage_bytes", "Memory usage in bytes", "bytes");
createGauge("cpu_usage_percent", "CPU usage percentage", "percent");
}
public void registerMeshMetrics() {
// Service mesh specific metrics
createCounter("mesh_requests_total", "Total service mesh requests", "requests");
createHistogram("mesh_request_duration_seconds", "Service mesh request duration", "seconds");
createCounter("mesh_errors_total", "Total service mesh errors", "errors");
createCounter("mesh_retries_total", "Total service mesh retries", "retries");
createCounter("mesh_circuit_breaker_opens", "Circuit breaker open events", "events");
createGauge("mesh_active_endpoints", "Active endpoints in mesh", "endpoints");
}
public void recordBusinessMetric(String metricName, double value, Map<String, String> dimensions) {
try {
io.opentelemetry.api.metrics.DoubleHistogram histogram = histograms.get(metricName);
if (histogram != null) {
histogram.record(value, convertToAttributes(dimensions));
} else {
// Create histogram on the fly if it doesn't exist
createHistogram(metricName, "Business metric: " + metricName, "units");
histograms.get(metricName).record(value, convertToAttributes(dimensions));
}
} catch (Exception e) {
System.err.println("Error recording business metric: " + e.getMessage());
}
}
public void recordMeshMetric(String metricName, double value, Map<String, String> meshDimensions) {
try {
Map<String, String> dimensions = new HashMap<>(meshDimensions);
dimensions.put("mesh.name", config.getMeshName());
dimensions.put("service.name", config.getServiceName());
dimensions.put("cluster", config.getClusterName());
recordBusinessMetric(metricName, value, dimensions);
} catch (Exception e) {
System.err.println("Error recording mesh metric: " + e.getMessage());
}
}
public void recordOperationMetric(String operationName, long duration, boolean success) {
Map<String, String> dimensions = new HashMap<>();
dimensions.put("operation", operationName);
dimensions.put("success", String.valueOf(success));
dimensions.put("service", config.getServiceName());
recordBusinessMetric("operation.duration_ms", duration, dimensions);
// Increment operation counter
String counterName = success ? "operations_success_total" : "operations_failed_total";
incrementCounter(counterName, 1, dimensions);
}
public void incrementCounter(String counterName, long increment, Map<String, String> dimensions) {
try {
io.opentelemetry.api.metrics.LongCounter counter = counters.get(counterName);
if (counter != null) {
counter.add(increment, convertToAttributes(dimensions));
}
} catch (Exception e) {
System.err.println("Error incrementing counter: " + e.getMessage());
}
}
public void recordHistogram(String histogramName, double value, Map<String, String> dimensions) {
try {
io.opentelemetry.api.metrics.DoubleHistogram histogram = histograms.get(histogramName);
if (histogram != null) {
histogram.record(value, convertToAttributes(dimensions));
}
} catch (Exception e) {
System.err.println("Error recording histogram: " + e.getMessage());
}
}
private void createCounter(String name, String description, String unit) {
io.opentelemetry.api.metrics.LongCounter counter = openTelemetry.getMeter(config.getServiceName())
.counterBuilder(name)
.setDescription(description)
.setUnit(unit)
.build();
counters.put(name, counter);
}
private void createHistogram(String name, String description, String unit) {
io.opentelemetry.api.metrics.DoubleHistogram histogram = openTelemetry.getMeter(config.getServiceName())
.histogramBuilder(name)
.setDescription(description)
.setUnit(unit)
.build();
histograms.put(name, histogram);
}
private void createUpDownCounter(String name, String description, String unit) {
io.opentelemetry.api.metrics.LongUpDownCounter counter = openTelemetry.getMeter(config.getServiceName())
.upDownCounterBuilder(name)
.setDescription(description)
.setUnit(unit)
.build();
upDownCounters.put(name, counter);
}
private void createGauge(String name, String description, String unit) {
// Gauges are implemented as asynchronous instruments
openTelemetry.getMeter(config.getServiceName())
.gaugeBuilder(name)
.setDescription(description)
.setUnit(unit)
.buildWithCallback(measurement -> {
// This will be called periodically to collect gauge values
double value = collectGaugeValue(name);
measurement.record(value);
});
}
private double collectGaugeValue(String gaugeName) {
switch (gaugeName) {
case "memory_usage_bytes":
return Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
case "cpu_usage_percent":
return getProcessCpuLoad();
case "mesh_active_endpoints":
return getActiveEndpointsCount();
default:
return 0.0;
}
}
private double getProcessCpuLoad() {
// Simplified CPU usage calculation
// In production, use proper system metrics collection
return Math.random() * 100; // Placeholder
}
private double getActiveEndpointsCount() {
// This would integrate with service mesh control plane
// For now, return a placeholder value
return 5.0; // Placeholder
}
private void startPeriodicMetricsCollection() {
metricsExecutor.scheduleAtFixedRate(() -> {
try {
collectSystemMetrics();
collectMeshMetrics();
} catch (Exception e) {
System.err.println("Error in periodic metrics collection: " + e.getMessage());
}
}, 0, 30, TimeUnit.SECONDS);
}
private void collectSystemMetrics() {
// Collect JVM metrics
Runtime runtime = Runtime.getRuntime();
long usedMemory = runtime.totalMemory() - runtime.freeMemory();
long maxMemory = runtime.maxMemory();
Map<String, String> dimensions = new HashMap<>();
dimensions.put("service", config.getServiceName());
recordBusinessMetric("jvm.memory.used", usedMemory, dimensions);
recordBusinessMetric("jvm.memory.max", maxMemory, dimensions);
recordBusinessMetric("jvm.threads.active", (double) Thread.activeCount(), dimensions);
}
private void collectMeshMetrics() {
// Collect service mesh specific metrics
// This would integrate with service mesh APIs
Map<String, String> dimensions = new HashMap<>();
dimensions.put("mesh", config.getMeshName());
dimensions.put("service", config.getServiceName());
dimensions.put("cluster", config.getClusterName());
// Placeholder mesh metrics
recordMeshMetric("mesh.endpoints.healthy", 4.0, dimensions);
recordMeshMetric("mesh.endpoints.total", 5.0, dimensions);
recordMeshMetric("mesh.request.rate", 100.0, dimensions);
}
private Attributes convertToAttributes(Map<String, String> dimensions) {
if (dimensions == null || dimensions.isEmpty()) {
return Attributes.empty();
}
Attributes.Builder builder = Attributes.builder();
for (Map.Entry<String, String> entry : dimensions.entrySet()) {
builder.put(entry.getKey(), entry.getValue());
}
return builder.build();
}
public void shutdown() {
metricsExecutor.shutdown();
try {
if (!metricsExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
metricsExecutor.shutdownNow();
}
} catch (InterruptedException e) {
metricsExecutor.shutdownNow();
Thread.currentThread().interrupt();
}
}
}

4. Distributed Logging

/**
* Distributed context-aware logger
*/
public class DistributedLogger {
private final OpenTelemetry openTelemetry;
private final org.slf4j.Logger slf4jLogger;
public DistributedLogger(OpenTelemetry openTelemetry) {
this.openTelemetry = openTelemetry;
this.slf4jLogger = org.slf4j.LoggerFactory.getLogger("service-mesh-observability");
}
public void log(String level, String message, Map<String, Object> fields) {
log(level, message, fields, null);
}
public void log(String level, String message, Map<String, Object> fields, Throwable throwable) {
// Get current span context
Span currentSpan = Span.current();
String traceId = currentSpan.getSpanContext().getTraceId();
String spanId = currentSpan.getSpanContext().getSpanId();
// Create structured log entry
Map<String, Object> logEntry = new HashMap<>();
logEntry.put("timestamp", Instant.now().toString());
logEntry.put("level", level);
logEntry.put("message", message);
logEntry.put("trace_id", traceId);
logEntry.put("span_id", spanId);
if (fields != null) {
logEntry.putAll(fields);
}
// Add span attributes if available
addSpanAttributes(logEntry, currentSpan);
// Log using appropriate level
String jsonLog = convertToJson(logEntry);
switch (level.toLowerCase()) {
case "error":
if (throwable != null) {
slf4jLogger.error(jsonLog, throwable);
} else {
slf4jLogger.error(jsonLog);
}
break;
case "warn":
slf4jLogger.warn(jsonLog);
break;
case "info":
slf4jLogger.info(jsonLog);
break;
case "debug":
slf4jLogger.debug(jsonLog);
break;
case "trace":
slf4jLogger.trace(jsonLog);
break;
default:
slf4jLogger.info(jsonLog);
}
// Also record log as span event
currentSpan.addEvent("log", Attributes.builder()
.put("log.level", level)
.put("log.message", message)
.build());
}
private void addSpanAttributes(Map<String, Object> logEntry, Span span) {
// This is a simplified implementation
// In a real scenario, you might extract custom span attributes
logEntry.put("service.name", getServiceNameFromContext());
logEntry.put("service.mesh", getMeshNameFromContext());
}
private String getServiceNameFromContext() {
// Extract from context or configuration
return "unknown-service";
}
private String getMeshNameFromContext() {
// Extract from context or configuration
return "unknown-mesh";
}
private String convertToJson(Map<String, Object> map) {
try {
ObjectMapper mapper = new ObjectMapper();
return mapper.writeValueAsString(map);
} catch (Exception e) {
// Fallback to simple string representation
return map.toString();
}
}
// Convenience methods
public void debug(String message, Map<String, Object> fields) {
log("debug", message, fields);
}
public void info(String message, Map<String, Object> fields) {
log("info", message, fields);
}
public void warn(String message, Map<String, Object> fields) {
log("warn", message, fields);
}
public void warn(String message, Map<String, Object> fields, Throwable throwable) {
log("warn", message, fields, throwable);
}
public void error(String message, Map<String, Object> fields) {
log("error", message, fields);
}
public void error(String message, Map<String, Object> fields, Throwable throwable) {
log("error", message, fields, throwable);
}
/**
* MDC (Mapped Diagnostic Context) support for SLF4J
*/
public void withContext(Map<String, String> context, Runnable operation) {
// Set MDC context
Map<String, String> previousContext = org.slf4j.MDC.getCopyOfContextMap();
try {
// Clear and set new context
org.slf4j.MDC.clear();
if (context != null) {
for (Map.Entry<String, String> entry : context.entrySet()) {
org.slf4j.MDC.put(entry.getKey(), entry.getValue());
}
}
// Add tracing context
Span currentSpan = Span.current();
if (currentSpan.getSpanContext().isValid()) {
org.slf4j.MDC.put("trace_id", currentSpan.getSpanContext().getTraceId());
org.slf4j.MDC.put("span_id", currentSpan.getSpanContext().getSpanId());
}
operation.run();
} finally {
// Restore previous context
org.slf4j.MDC.clear();
if (previousContext != null) {
org.slf4j.MDC.setContextMap(previousContext);
}
}
}
}

5. Service Mesh Integration

/**
* Service mesh integration for advanced observability
*/
public class ServiceMeshIntegrator {
private final ObservabilityConfig config;
private final MeshClient meshClient;
private final ScheduledExecutorService meshExecutor;
private final Map<String, Object> meshState;
public ServiceMeshIntegrator(ObservabilityConfig config) {
this.config = config;
this.meshClient = createMeshClient(config);
this.meshExecutor = Executors.newScheduledThreadPool(2);
this.meshState = new ConcurrentHashMap<>();
}
public void initialize() {
startMeshStateCollection();
startHealthMonitoring();
registerServiceWithMesh();
}
public ServiceMeshInsights collectInsights() {
try {
ServiceMeshInsights.InsightsBuilder builder = ServiceMeshInsights.builder();
// Collect traffic insights
TrafficInsights traffic = collectTrafficInsights();
builder.trafficInsights(traffic);
// Collect topology insights
TopologyInsights topology = collectTopologyInsights();
builder.topologyInsights(topology);
// Collect security insights
SecurityInsights security = collectSecurityInsights();
builder.securityInsights(security);
// Collect performance insights
PerformanceInsights performance = collectPerformanceInsights();
builder.performanceInsights(performance);
return builder.build();
} catch (Exception e) {
System.err.println("Error collecting mesh insights: " + e.getMessage());
return ServiceMeshInsights.empty();
}
}
public ServiceMeshHealth checkHealth() {
try {
ServiceMeshHealth.HealthBuilder builder = ServiceMeshHealth.builder();
// Check control plane health
boolean controlPlaneHealthy = checkControlPlaneHealth();
builder.controlPlaneHealthy(controlPlaneHealthy);
// Check data plane health
boolean dataPlaneHealthy = checkDataPlaneHealth();
builder.dataPlaneHealthy(dataPlaneHealthy);
// Check service health
Map<String, Boolean> serviceHealth = checkServiceHealth();
builder.serviceHealth(serviceHealth);
// Check policy enforcement
boolean policiesEnforced = checkPolicyEnforcement();
builder.policiesEnforced(policiesEnforced);
return builder.build();
} catch (Exception e) {
System.err.println("Error checking mesh health: " + e.getMessage());
return ServiceMeshHealth.unhealthy(e.getMessage());
}
}
public Map<String, Object> getMeshConfig() {
try {
return meshClient.getMeshConfiguration();
} catch (Exception e) {
System.err.println("Error getting mesh configuration: " + e.getMessage());
return Collections.emptyMap();
}
}
public List<MeshEndpoint> getEndpoints(String serviceName) {
try {
return meshClient.getEndpoints(serviceName);
} catch (Exception e) {
System.err.println("Error getting endpoints for service: " + serviceName);
return Collections.emptyList();
}
}
private void startMeshStateCollection() {
meshExecutor.scheduleAtFixedRate(() -> {
try {
updateMeshState();
} catch (Exception e) {
System.err.println("Error updating mesh state: " + e.getMessage());
}
}, 0, 60, TimeUnit.SECONDS);
}
private void startHealthMonitoring() {
meshExecutor.scheduleAtFixedRate(() -> {
try {
ServiceMeshHealth health = checkHealth();
meshState.put("health", health);
if (!health.isHealthy()) {
System.warn("Service mesh health check failed: " + health.getHealthStatus());
}
} catch (Exception e) {
System.err.println("Error in health monitoring: " + e.getMessage());
}
}, 0, 30, TimeUnit.SECONDS);
}
private void registerServiceWithMesh() {
try {
Map<String, Object> registration = new HashMap<>();
registration.put("serviceName", config.getServiceName());
registration.put("version", config.getServiceVersion());
registration.put("environment", config.getEnvironment());
registration.put("cluster", config.getClusterName());
meshClient.registerService(registration);
System.info("Service registered with mesh: " + config.getServiceName());
} catch (Exception e) {
System.err.println("Error registering service with mesh: " + e.getMessage());
}
}
private void updateMeshState() {
try {
// Update service endpoints
List<MeshEndpoint> endpoints = getEndpoints(config.getServiceName());
meshState.put("endpoints", endpoints);
// Update traffic metrics
Map<String, Object> trafficMetrics = meshClient.getTrafficMetrics();
meshState.put("traffic", trafficMetrics);
// Update policy state
Map<String, Object> policies = meshClient.getPolicies();
meshState.put("policies", policies);
} catch (Exception e) {
System.err.println("Error updating mesh state: " + e.getMessage());
}
}
private TrafficInsights collectTrafficInsights() {
try {
Map<String, Object> trafficData = (Map<String, Object>) meshState.get("traffic");
if (trafficData == null) {
return TrafficInsights.empty();
}
return TrafficInsights.builder()
.requestRate(getDouble(trafficData, "requestRate", 0.0))
.errorRate(getDouble(trafficData, "errorRate", 0.0))
.p99Latency(getDouble(trafficData, "p99Latency", 0.0))
.throughput(getDouble(trafficData, "throughput", 0.0))
.build();
} catch (Exception e) {
return TrafficInsights.empty();
}
}
private TopologyInsights collectTopologyInsights() {
try {
@SuppressWarnings("unchecked")
List<MeshEndpoint> endpoints = (List<MeshEndpoint>) meshState.get("endpoints");
return TopologyInsights.builder()
.serviceCount(getServiceCount())
.endpointCount(endpoints != null ? endpoints.size() : 0)
.connectedServices(getConnectedServices())
.meshDensity(calculateMeshDensity())
.build();
} catch (Exception e) {
return TopologyInsights.empty();
}
}
private SecurityInsights collectSecurityInsights() {
try {
@SuppressWarnings("unchecked")
Map<String, Object> policies = (Map<String, Object>) meshState.get("policies");
return SecurityInsights.builder()
.mtlsEnabled(getBoolean(policies, "mtlsEnabled", false))
.authPolicies(getInt(policies, "authPolicies", 0))
.networkPolicies(getInt(policies, "networkPolicies", 0))
.securityScore(calculateSecurityScore(policies))
.build();
} catch (Exception e) {
return SecurityInsights.empty();
}
}
private PerformanceInsights collectPerformanceInsights() {
try {
Map<String, Object> trafficData = (Map<String, Object>) meshState.get("traffic");
return PerformanceInsights.builder()
.averageLatency(getDouble(trafficData, "avgLatency", 0.0))
.throughput(getDouble(trafficData, "throughput", 0.0))
.errorRate(getDouble(trafficData, "errorRate", 0.0))
.saturation(getDouble(trafficData, "saturation", 0.0))
.build();
} catch (Exception e) {
return PerformanceInsights.empty();
}
}
private MeshClient createMeshClient(ObservabilityConfig config) {
// Factory method to create appropriate mesh client
switch (config.getMeshName().toLowerCase()) {
case "istio":
return new IstioMeshClient(config);
case "linkerd":
return new LinkerdMeshClient(config);
case "consul":
return new ConsulMeshClient(config);
default:
return new DefaultMeshClient(config);
}
}
// Helper methods
private double getDouble(Map<String, Object> map, String key, double defaultValue) {
Object value = map.get(key);
return value instanceof Number ? ((Number) value).doubleValue() : defaultValue;
}
private int getInt(Map<String, Object> map, String key, int defaultValue) {
Object value = map.get(key);
return value instanceof Number ? ((Number) value).intValue() : defaultValue;
}
private boolean getBoolean(Map<String, Object> map, String key, boolean defaultValue) {
Object value = map.get(key);
return value instanceof Boolean ? (Boolean) value : defaultValue;
}
private int getServiceCount() {
// This would query the mesh control plane
return 10; // Placeholder
}
private List<String> getConnectedServices() {
// This would query the mesh control plane
return Arrays.asList("service-a", "service-b", "service-c"); // Placeholder
}
private double calculateMeshDensity() {
// Calculate mesh density based on service connections
return 0.75; // Placeholder
}
private double calculateSecurityScore(Map<String, Object> policies) {
// Calculate security score based on policies
return 85.0; // Placeholder
}
private boolean checkControlPlaneHealth() {
try {
return meshClient.checkControlPlaneHealth();
} catch (Exception e) {
return false;
}
}
private boolean checkDataPlaneHealth() {
try {
return meshClient.checkDataPlaneHealth();
} catch (Exception e) {
return false;
}
}
private Map<String, Boolean> checkServiceHealth() {
try {
return meshClient.checkServiceHealth();
} catch (Exception e) {
return Collections.singletonMap(config.getServiceName(), false);
}
}
private boolean checkPolicyEnforcement() {
try {
return meshClient.checkPolicyEnforcement();
} catch (Exception e) {
return false;
}
}
public void shutdown() {
meshExecutor.shutdown();
try {
if (!meshExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
meshExecutor.shutdownNow();
}
} catch (InterruptedException e) {
meshExecutor.shutdownNow();
Thread.currentThread().interrupt();
}
}
}
/**
* Service mesh client interface
*/
interface MeshClient {
void registerService(Map<String, Object> registration);
List<MeshEndpoint> getEndpoints(String serviceName);
Map<String, Object> getTrafficMetrics();
Map<String, Object> getPolicies();
Map<String, Object> getMeshConfiguration();
boolean checkControlPlaneHealth();
boolean checkDataPlaneHealth();
Map<String, Boolean> checkServiceHealth();
boolean checkPolicyEnforcement();
}
/**
* Istio mesh client implementation
*/
class IstioMeshClient implements MeshClient {
private final ObservabilityConfig config;
public IstioMeshClient(ObservabilityConfig config) {
this.config = config;
}
@Override
public void registerService(Map<String, Object> registration) {
// Implement Istio service registration
System.info("Registering service with Istio: " + registration);
}
@Override
public List<MeshEndpoint> getEndpoints(String serviceName) {
// Query Istio Pilot for endpoints
return Collections.emptyList(); // Simplified
}
@Override
public Map<String, Object> getTrafficMetrics() {
// Query Istio Mixer or Telemetry API for metrics
Map<String, Object> metrics = new HashMap<>();
metrics.put("requestRate", 100.0);
metrics.put("errorRate", 0.5);
metrics.put("p99Latency", 250.0);
metrics.put("avgLatency", 50.0);
metrics.put("throughput", 1000.0);
return metrics;
}
@Override
public Map<String, Object> getPolicies() {
// Query Istio Pilot for policies
Map<String, Object> policies = new HashMap<>();
policies.put("mtlsEnabled", true);
policies.put("authPolicies", 3);
policies.put("networkPolicies", 5);
return policies;
}
@Override
public Map<String, Object> getMeshConfiguration() {
// Get Istio mesh configuration
Map<String, Object> config = new HashMap<>();
config.put("meshId", "istio-mesh");
config.put("version", "1.16.0");
config.put("trustDomain", "cluster.local");
return config;
}
@Override
public boolean checkControlPlaneHealth() {
// Check Istiod health
return true; // Simplified
}
@Override
public boolean checkDataPlaneHealth() {
// Check Envoy proxy health
return true; // Simplified
}
@Override
public Map<String, Boolean> checkServiceHealth() {
// Check service health via Istio
Map<String, Boolean> health = new HashMap<>();
health.put(config.getServiceName(), true);
return health;
}
@Override
public boolean checkPolicyEnforcement() {
// Check if policies are being enforced
return true; // Simplified
}
}
// Similar implementations for LinkerdMeshClient, ConsulMeshClient, DefaultMeshClient

6. Domain Models

/**
* Service mesh insights data model
*/
public class ServiceMeshInsights {
private final TrafficInsights trafficInsights;
private final TopologyInsights topologyInsights;
private final SecurityInsights securityInsights;
private final PerformanceInsights performanceInsights;
private ServiceMeshInsights(Builder builder) {
this.trafficInsights = builder.trafficInsights;
this.topologyInsights = builder.topologyInsights;
this.securityInsights = builder.securityInsights;
this.performanceInsights = builder.performanceInsights;
}
// Getters
public TrafficInsights getTrafficInsights() { return trafficInsights; }
public TopologyInsights getTopologyInsights() { return topologyInsights; }
public SecurityInsights getSecurityInsights() { return securityInsights; }
public PerformanceInsights getPerformanceInsights() { return performanceInsights; }
public static ServiceMeshInsights empty() {
return new ServiceMeshInsights(
TrafficInsights.empty(),
TopologyInsights.empty(),
SecurityInsights.empty(),
PerformanceInsights.empty()
);
}
public static class Builder {
private TrafficInsights trafficInsights = TrafficInsights.empty();
private TopologyInsights topologyInsights = TopologyInsights.empty();
private SecurityInsights securityInsights = SecurityInsights.empty();
private PerformanceInsights performanceInsights = PerformanceInsights.empty();
public Builder trafficInsights(TrafficInsights trafficInsights) {
this.trafficInsights = trafficInsights;
return this;
}
public Builder topologyInsights(TopologyInsights topologyInsights) {
this.topologyInsights = topologyInsights;
return this;
}
public Builder securityInsights(SecurityInsights securityInsights) {
this.securityInsights = securityInsights;
return this;
}
public Builder performanceInsights(PerformanceInsights performanceInsights) {
this.performanceInsights = performanceInsights;
return this;
}
public ServiceMeshInsights build() {
return new ServiceMeshInsights(this);
}
}
}
/**
* Traffic insights
*/
public class TrafficInsights {
private final double requestRate;
private final double errorRate;
private final double p99Latency;
private final double throughput;
public TrafficInsights(double requestRate, double errorRate, double p99Latency, double throughput) {
this.requestRate = requestRate;
this.errorRate = errorRate;
this.p99Latency = p99Latency;
this.throughput = throughput;
}
// Getters
public double getRequestRate() { return requestRate; }
public double getErrorRate() { return errorRate; }
public double getP99Latency() { return p99Latency; }
public double getThroughput() { return throughput; }
public static TrafficInsights empty() {
return new TrafficInsights(0.0, 0.0, 0.0, 0.0);
}
public static class Builder {
private double requestRate;
private double errorRate;
private double p99Latency;
private double throughput;
public Builder requestRate(double requestRate) {
this.requestRate = requestRate;
return this;
}
public Builder errorRate(double errorRate) {
this.errorRate = errorRate;
return this;
}
public Builder p99Latency(double p99Latency) {
this.p99Latency = p99Latency;
return this;
}
public Builder throughput(double throughput) {
this.throughput = throughput;
return this;
}
public TrafficInsights build() {
return new TrafficInsights(requestRate, errorRate, p99Latency, throughput);
}
}
}
/**
* Service mesh health model
*/
public class ServiceMeshHealth {
private final boolean controlPlaneHealthy;
private final boolean dataPlaneHealthy;
private final Map<String, Boolean> serviceHealth;
private final boolean policiesEnforced;
private final String healthStatus;
private ServiceMeshHealth(Builder builder) {
this.controlPlaneHealthy = builder.controlPlaneHealthy;
this.dataPlaneHealthy = builder.dataPlaneHealthy;
this.serviceHealth = builder.serviceHealth;
this.policiesEnforced = builder.policiesEnforced;
this.healthStatus = calculateHealthStatus();
}
public boolean isHealthy() {
return controlPlaneHealthy && dataPlaneHealthy && 
serviceHealth.values().stream().allMatch(Boolean::booleanValue) &&
policiesEnforced;
}
public String getHealthStatus() {
return healthStatus;
}
private String calculateHealthStatus() {
if (isHealthy()) {
return "HEALTHY";
} else if (!controlPlaneHealthy) {
return "CONTROL_PLANE_UNHEALTHY";
} else if (!dataPlaneHealthy) {
return "DATA_PLANE_UNHEALTHY";
} else if (serviceHealth.containsValue(false)) {
return "SERVICES_UNHEALTHY";
} else if (!policiesEnforced) {
return "POLICIES_NOT_ENFORCED";
} else {
return "UNKNOWN";
}
}
public static ServiceMeshHealth unhealthy(String reason) {
return new ServiceMeshHealth(false, false, 
Collections.singletonMap("unknown", false), false);
}
public static class Builder {
private boolean controlPlaneHealthy;
private boolean dataPlaneHealthy;
private Map<String, Boolean> serviceHealth = new HashMap<>();
private boolean policiesEnforced;
public Builder controlPlaneHealthy(boolean controlPlaneHealthy) {
this.controlPlaneHealthy = controlPlaneHealthy;
return this;
}
public Builder dataPlaneHealthy(boolean dataPlaneHealthy) {
this.dataPlaneHealthy = dataPlaneHealthy;
return this;
}
public Builder serviceHealth(Map<String, Boolean> serviceHealth) {
this.serviceHealth = serviceHealth;
return this;
}
public Builder policiesEnforced(boolean policiesEnforced) {
this.policiesEnforced = policiesEnforced;
return this;
}
public ServiceMeshHealth build() {
return new ServiceMeshHealth(this);
}
}
}
// Additional domain models for TopologyInsights, SecurityInsights, PerformanceInsights, MeshEndpoint

7. Spring Boot Integration

/**
* Spring Boot Auto-Configuration
*/
@Configuration
@EnableConfigurationProperties(ServiceMeshObservabilityProperties.class)
public class ServiceMeshObservabilityAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public ServiceMeshObservability serviceMeshObservability(ServiceMeshObservabilityProperties properties) {
ObservabilityConfig config = ObservabilityConfig.builder()
.serviceName(properties.getServiceName())
.serviceVersion(properties.getServiceVersion())
.environment(properties.getEnvironment())
.meshName(properties.getMeshName())
.clusterName(properties.getClusterName())
.otlpEndpoint(properties.getOtlpEndpoint())
.metricsPort(properties.getMetricsPort())
.enableTracing(properties.isEnableTracing())
.enableMetrics(properties.isEnableMetrics())
.enableLogging(properties.isEnableLogging())
.build();
return ServiceMeshObservability.initialize(config);
}
@Bean
public ObservabilityAspect observabilityAspect() {
return new ObservabilityAspect();
}
@Bean
public ObservabilityFilter observabilityFilter() {
return new ObservabilityFilter();
}
}
/**
* Configuration properties
*/
@ConfigurationProperties(prefix = "servicemesh.observability")
public class ServiceMeshObservabilityProperties {
private String serviceName = "unknown-service";
private String serviceVersion = "1.0.0";
private String environment = "development";
private String meshName = "istio";
private String clusterName = "default";
private String otlpEndpoint = "http://localhost:4317";
private int metricsPort = 9464;
private boolean enableTracing = true;
private boolean enableMetrics = true;
private boolean enableLogging = true;
// Getters and setters
public String getServiceName() { return serviceName; }
public void setServiceName(String serviceName) { this.serviceName = serviceName; }
public String getServiceVersion() { return serviceVersion; }
public void setServiceVersion(String serviceVersion) { this.serviceVersion = serviceVersion; }
public String getEnvironment() { return environment; }
public void setEnvironment(String environment) { this.environment = environment; }
public String getMeshName() { return meshName; }
public void setMeshName(String meshName) { this.meshName = meshName; }
public String getClusterName() { return clusterName; }
public void setClusterName(String clusterName) { this.clusterName = clusterName; }
public String getOtlpEndpoint() { return otlpEndpoint; }
public void setOtlpEndpoint(String otlpEndpoint) { this.otlpEndpoint = otlpEndpoint; }
public int getMetricsPort() { return metricsPort; }
public void setMetricsPort(int metricsPort) { this.metricsPort = metricsPort; }
public boolean isEnableTracing() { return enableTracing; }
public void setEnableTracing(boolean enableTracing) { this.enableTracing = enableTracing; }
public boolean isEnableMetrics() { return enableMetrics; }
public void setEnableMetrics(boolean enableMetrics) { this.enableMetrics = enableMetrics; }
public boolean isEnableLogging() { return enableLogging; }
public void setEnableLogging(boolean enableLogging) { this.enableLogging = enableLogging; }
}
/**
* Spring AOP aspect for automatic observability
*/
@Aspect
@Component
public class ObservabilityAspect {
private final ServiceMeshObservability observability;
public ObservabilityAspect() {
this.observability = ServiceMeshObservability.getInstance();
}
@Around("@annotation(observable)")
public Object observeMethod(ProceedingJoinPoint joinPoint, Observable observable) throws Throwable {
String operationName = !observable.value().isEmpty() ? 
observable.value() : joinPoint.getSignature().toShortString();
Map<String, String> attributes = new HashMap<>();
attributes.put("class", joinPoint.getSignature().getDeclaringTypeName());
attributes.put("method", joinPoint.getSignature().getName());
try (ObservabilityScope scope = observability.startOperation(operationName, attributes)) {
Object result = joinPoint.proceed();
scope.success();
return result;
} catch (Throwable throwable) {
observability.startOperation(operationName, attributes).error(throwable);
throw throwable;
}
}
}
/**
* HTTP filter for observability
*/
@Component
public class ObservabilityFilter implements Filter {
private final ServiceMeshObservability observability;
public ObservabilityFilter() {
this.observability = ServiceMeshObservability.getInstance();
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
throws IOException, ServletException {
HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpServletResponse httpResponse = (HttpServletResponse) response;
// Extract headers for context propagation
Map<String, String> headers = extractHeaders(httpRequest);
Context context = observability.extractContext(headers);
String operationName = httpRequest.getMethod() + " " + httpRequest.getRequestURI();
Map<String, String> attributes = new HashMap<>();
attributes.put("http.method", httpRequest.getMethod());
attributes.put("http.route", httpRequest.getRequestURI());
attributes.put("http.user_agent", httpRequest.getHeader("User-Agent"));
try (ObservabilityScope scope = observability.startOperation(operationName, attributes)) {
// Add tracing headers to response
Map<String, String> propagationHeaders = scope.getPropagationHeaders();
for (Map.Entry<String, String> header : propagationHeaders.entrySet()) {
httpResponse.setHeader(header.getKey(), header.getValue());
}
chain.doFilter(request, response);
scope.setAttribute("http.status_code", String.valueOf(httpResponse.getStatus()));
if (httpResponse.getStatus() < 400) {
scope.success();
} else {
scope.error("HTTP_" + httpResponse.getStatus(), "HTTP error");
}
} catch (Exception e) {
observability.startOperation(operationName, attributes).error(e);
throw e;
}
}
private Map<String, String> extractHeaders(HttpServletRequest request) {
Map<String, String> headers = new HashMap<>();
Enumeration<String> headerNames = request.getHeaderNames();
while (headerNames.hasMoreElements()) {
String headerName = headerNames.nextElement();
headers.put(headerName, request.getHeader(headerName));
}
return headers;
}
}
/**
* Annotation for observable methods
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Observable {
String value() default "";
}

8. Usage Examples

/**
* Demo service showing observability usage
*/
@Service
public class OrderService {
private final ServiceMeshObservability observability;
private final DistributedLogger logger;
public OrderService() {
this.observability = ServiceMeshObservability.getInstance();
this.logger = observability.getDistributedLogger();
}
@Observable("order.process")
public Order processOrder(OrderRequest request) {
Map<String, String> attributes = new HashMap<>();
attributes.put("order.id", request.getOrderId());
attributes.put("customer.id", request.getCustomerId());
attributes.put("amount", String.valueOf(request.getAmount()));
try (ObservabilityScope scope = observability.startOperation("order.process", attributes)) {
logger.info("Processing order", Map.of(
"orderId", request.getOrderId(),
"customerId", request.getCustomerId(),
"amount", request.getAmount()
));
// Validate order
scope.addEvent("order.validation.start", Collections.emptyMap());
validateOrder(request);
scope.addEvent("order.validation.complete", Collections.emptyMap());
// Process payment
scope.addEvent("payment.processing.start", Collections.emptyMap());
PaymentResult payment = processPayment(request);
scope.addEvent("payment.processing.complete", 
Map.of("payment.status", payment.getStatus()));
// Update inventory
updateInventory(request);
// Record business metric
observability.recordBusinessMetric("order.value", request.getAmount(), 
Map.of("customer.tier", getCustomerTier(request.getCustomerId())));
Order order = createOrder(request, payment);
scope.success();
return order;
} catch (ValidationException e) {
observability.startOperation("order.process", attributes).error(e);
logger.error("Order validation failed", 
Map.of("orderId", request.getOrderId(), "error", e.getMessage()), e);
throw e;
} catch (PaymentException e) {
observability.startOperation("order.process", attributes).error(e);
logger.error("Payment processing failed", 
Map.of("orderId", request.getOrderId(), "error", e.getMessage()), e);
throw e;
}
}
public Order processOrderWithMeshContext(OrderRequest request, Map<String, String> headers) {
// Extract context from incoming headers
Context context = observability.extractContext(headers);
try (io.opentelemetry.context.Scope ignored = context.makeCurrent()) {
return processOrder(request);
}
}
public void checkServiceMeshHealth() {
ServiceMeshHealth health = observability.getMeshHealth();
ServiceMeshInsights insights = observability.getMeshInsights();
logger.info("Service mesh health check", Map.of(
"healthy", health.isHealthy(),
"status", health.getHealthStatus(),
"traffic_rate", insights.getTrafficInsights().getRequestRate(),
"error_rate", insights.getTrafficInsights().getErrorRate()
));
if (!health.isHealthy()) {
// Trigger alert or fallback behavior
handleMeshUnhealthy(health);
}
}
private void validateOrder(OrderRequest request) {
// Validation logic
if (request.getAmount() <= 0) {
throw new ValidationException("Invalid order amount");
}
}
private PaymentResult processPayment(OrderRequest request) {
// Make external payment service call with observability
Map<String, String> callAttributes = new HashMap<>();
callAttributes.put("payment.gateway", "stripe");
callAttributes.put("amount", String.valueOf(request.getAmount()));
try (ObservabilityScope scope = observability.startClientCall(
"payment-service", "process", callAttributes)) {
// Add headers for propagation
Map<String, String> headers = scope.getPropagationHeaders();
// Make HTTP call with headers
PaymentResult result = paymentClient.processPayment(request, headers);
scope.setAttribute("payment.status", result.getStatus());
scope.setAttribute("payment.transaction_id", result.getTransactionId());
if ("SUCCESS".equals(result.getStatus())) {
scope.success();
} else {
scope.error("PAYMENT_FAILED", result.getErrorMessage());
}
return result;
}
}
private void updateInventory(OrderRequest request) {
// Inventory update logic
observability.recordBusinessMetric("inventory.update", 1.0,
Map.of("product.count", String.valueOf(request.getItems().size())));
}
private Order createOrder(OrderRequest request, PaymentResult payment) {
return new Order(UUID.randomUUID().toString(), request, payment);
}
private String getCustomerTier(String customerId) {
// Determine customer tier
return "standard";
}
private void handleMeshUnhealthy(ServiceMeshHealth health) {
// Handle unhealthy mesh scenario
logger.warn("Service mesh is unhealthy, implementing fallback", 
Map.of("health_status", health.getHealthStatus()));
}
}
/**
* Demo application
*/
@SpringBootApplication
@EnableAspectJAutoProxy
public class ServiceMeshObservabilityDemo {
public static void main(String[] args) {
// Initialize observability
ObservabilityConfig config = ObservabilityConfig.builder()
.serviceName("order-service")
.serviceVersion("1.0.0")
.environment("production")
.meshName("istio")
.clusterName("production-cluster")
.otlpEndpoint("http://jaeger:4317")
.metricsPort(9464)
.build();
ServiceMeshObservability.initialize(config);
// Start Spring Boot application
SpringApplication.run(ServiceMeshObservabilityDemo.class, args);
}
@Bean
public CommandLineRunner demo(OrderService orderService) {
return args -> {
// Demonstrate observability
OrderRequest request = new OrderRequest("cust-123", "order-456", 99.99);
orderService.processOrder(request);
// Check mesh health
orderService.checkServiceMeshHealth();
};
}
}

Key Features

  • Distributed Tracing: End-to-end tracing with OpenTelemetry
  • Metrics Collection: Business and mesh-specific metrics
  • Structured Logging: Context-aware distributed logging
  • Service Mesh Integration: Istio, Linkerd, Consul support
  • Health Monitoring: Mesh and service health checks
  • Spring Boot Integration: Auto-configuration and AOP
  • Context Propagation: W3C trace context and baggage
  • Performance Insights: Traffic, topology, security insights

Configuration Example

# application.yml
servicemesh:
observability:
service-name: "order-service"
service-version: "1.0.0"
environment: "production"
mesh-name: "istio"
cluster-name: "production-cluster"
otlp-endpoint: "http://jaeger:4317"
metrics-port: 9464
enable-tracing: true
enable-metrics: true
enable-logging: true

This comprehensive observability implementation provides production-ready monitoring for Java microservices in service mesh environments with minimal configuration and maximum insights.

Category : JAVA

Leave a Reply

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


Macro Nepal Helper