Observability & Production Readiness

implementation "org.springframework.boot:spring-boot-starter-actuator"
runtimeOnly "io.micrometer:micrometer-registry-prometheus"

management:
  endpoints:
    web:
      exposure:
        include: health,info,prometheus,metrics
  metrics:
    tags:
      application: ${spring.application.name}
      environment: ${spring.profiles.active}

@Service
class OrderService {
  private final Counter ordersCreated;
  private final Timer checkoutTimer;
  private final AtomicInteger pendingOrders = new AtomicInteger();

  OrderService(MeterRegistry registry) {
    ordersCreated = registry.counter("orders.created", "channel", "web");
    checkoutTimer = registry.timer("checkout.duration");
    registry.gauge("orders.pending", pendingOrders);
  }

  Order placeOrder(OrderRequest req) {
    return checkoutTimer.record(() -> {
      pendingOrders.incrementAndGet();
      try {
        Order order = doCheckout(req);
        ordersCreated.increment();
        return order;
      } finally {
        pendingOrders.decrementAndGet();
      }
    });
  }
}

@Timed(value = "payment.charge", description = "Payment gateway round-trip")
@Counted(value = "payment.attempts")
public PaymentResult charge(ChargeRequest req) {
  return gateway.charge(req);
}

// Enable aspect (if not using Boot auto-config for it)
@Configuration
@EnableAspectJAutoProxy
class MetricsAspectConfig {
  @Bean
  TimedAspect timedAspect(MeterRegistry registry) {
    return new TimedAspect(registry);
  }
}

scrape_configs:
  - job_name: order-service
    metrics_path: /actuator/prometheus
    static_configs:
      - targets: ["order-service:8080"]

# HELP http_server_requests_seconds Duration of HTTP server request handling
# TYPE http_server_requests_seconds histogram
http_server_requests_seconds_bucket{method="GET",uri="/api/orders/{id}",status="200",le="0.1"} 842.0
http_server_requests_seconds_count{method="GET",uri="/api/orders/{id}",status="200"} 1204.0

// version-traceId-spanId-flags
traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01

management:
  tracing:
    sampling:
      probability: 0.1        # 10% in prod; 1.0 in dev
  zipkin:
    tracing:
      endpoint: http://zipkin:9411/api/v2/spans

management:
  otlp:
    tracing:
      endpoint: http://otel-collector:4318/v1/traces

@Service
class FraudCheckService {
  private final ObservationRegistry observations;

  boolean check(Order order) {
    return Observation.createNotStarted("fraud.check", observations)
        .lowCardinalityKeyValue("payment.method", order.paymentMethod())
        .observe(() -> runRules(order));
  }
}

management:
  tracing:
    baggage:
      remote-fields: tenant-id, experiment
      correlation:
        fields: tenant-id, experiment

@Component
class TenantBaggageFilter implements WebFilter {
  @Override
  public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
    String tenant = exchange.getRequest().getHeaders().getFirst("X-Tenant-Id");
    if (tenant != null) {
      BaggageField.create("tenant-id").updateValue(tenant);
    }
    return chain.filter(exchange);
  }
}

@Slf4j
@Service
class PaymentService {
  void charge(String orderId, BigDecimal amount) {
    log.info("Charging order {} amount {}", orderId, amount);
    try {
      gateway.charge(amount);
    } catch (PaymentException ex) {
      log.warn("Payment failed for order {}: {}", orderId, ex.getMessage());
      throw ex;
    }
  }
}

implementation "net.logstash.logback:logstash-logback-encoder:7.4"

{"@timestamp":"2026-06-04T10:15:00.123Z","level":"INFO","logger":"c.a.OrderService",
 "message":"Order created","orderId":"ord_42","traceId":"4bf92f3577b34da6",
 "spanId":"00f067aa0ba902b7","tenant-id":"acme"}

@Component
class RequestMdcFilter extends OncePerRequestFilter {
  @Override
  protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res,
                                  FilterChain chain) throws ServletException, IOException {
    try {
      MDC.put("requestId", req.getHeader("X-Request-Id") != null
          ? req.getHeader("X-Request-Id") : UUID.randomUUID().toString());
      MDC.put("userId", resolveUserId(req).orElse("anonymous"));
      // traceId/spanId auto-populated by Micrometer Tracing when correlation enabled
      chain.doFilter(req, res);
    } finally {
      MDC.clear();
    }
  }
}

<configuration>
  <include resource="org/springframework/boot/logging/logback/defaults.xml"/>

  <springProfile name="local">
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
      <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} trace=%X{traceId} - %msg%n</pattern>
      </encoder>
    </appender>
    <root level="INFO">
      <appender-ref ref="CONSOLE"/>
    </root>
    <logger name="com.acme" level="DEBUG"/>
  </springProfile>

  <springProfile name="prod">
    <appender name="JSON" class="ch.qos.logback.core.ConsoleAppender">
      <encoder class="net.logstash.logback.encoder.LogstashEncoder">
        <includeMdcKeyName>traceId</includeMdcKeyName>
        <includeMdcKeyName>spanId</includeMdcKeyName>
        <includeMdcKeyName>requestId</includeMdcKeyName>
        <includeMdcKeyName>userId</includeMdcKeyName>
      </encoder>
    </appender>
    <appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
      <queueSize>8192</queueSize>
      <discardingThreshold>0</discardingThreshold>
      <appender-ref ref="JSON"/>
    </appender>
    <root level="INFO">
      <appender-ref ref="ASYNC"/>
    </root>
  </springProfile>
</configuration>

# application-prod.yml
logging:
  level:
    root: INFO
    com.acme: INFO
    org.springframework.web: WARN
    org.hibernate.SQL: WARN

management:
  endpoint:
    health:
      probes:
        enabled: true
      show-details: when_authorized
  endpoints:
    web:
      exposure:
        include: health,prometheus

livenessProbe:
  httpGet:
    path: /actuator/health/liveness
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 10
readinessProbe:
  httpGet:
    path: /actuator/health/readiness
    port: 8080
  initialDelaySeconds: 10
  periodSeconds: 5

@Component
class PaymentGatewayHealth implements HealthIndicator {
  private final PaymentClient client;

  @Override
  public Health health() {
    try {
      client.ping();
      return Health.up().withDetail("gateway", "reachable").build();
    } catch (Exception ex) {
      return Health.down(ex).withDetail("gateway", "unreachable").build();
    }
  }
}

// Group only critical deps for readiness
@Configuration
class ReadinessGroups {
  @Bean
  HealthContributorRegistryCustomizer readinessGroups() {
    return registry -> registry.registerContributorGroup("readiness",
        List.of("db", "redis", "paymentGatewayHealth"));
  }
}

server:
  shutdown: graceful

spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s

@Component
class DrainOnShutdown {
  @EventListener
  void onShutdown(ContextClosedEvent event) {
    log.info("Shutdown initiated — draining work");
    // stop schedulers, close custom thread pools
  }
}