관측성 베이스라인: 로그·메트릭·트레이스

<!-- logback-spring.xml -->
<configuration>
  <springProfile name="prod">
    <appender name="JSON" class="ch.qos.logback.core.ConsoleAppender">
      <encoder class="net.logstash.logback.encoder.LogstashEncoder">
        <!-- 기본 필드: timestamp, level, logger_name, message, stack_trace -->
        <includeMdcKeyName>traceId</includeMdcKeyName>
        <includeMdcKeyName>spanId</includeMdcKeyName>
        <includeMdcKeyName>requestId</includeMdcKeyName>
        <!-- 민감정보 마스킹 -->
        <jsonGeneratorDecorator class="net.logstash.logback.mask.MaskingJsonGeneratorDecorator">
          <valueMask>
            <value>(?&lt;=password["\s:=]+)[\w]+</value>
            <mask>****</mask>
          </valueMask>
        </jsonGeneratorDecorator>
      </encoder>
    </appender>
    <root level="INFO">
      <appender-ref ref="JSON" />
    </root>
  </springProfile>
</configuration>

{
  "timestamp": "2025-12-16T10:30:15.123+09:00",
  "level": "ERROR",
  "logger_name": "c.e.o.OrderService",
  "message": "재고 부족으로 주문 실패",
  "traceId": "abc123def456",
  "spanId": "span789",
  "requestId": "req-001",
  "orderId": 12345,
  "productId": 678,
  "stack_trace": "java.lang.IllegalStateException: ..."
}

// ❌ 안티패턴 1: 무의미한 로그
log.info("메서드 진입");
log.info("메서드 종료");

// ❌ 안티패턴 2: 민감정보 노출
log.info("사용자 로그인: email={}, password={}", email, password);

// ❌ 안티패턴 3: 예외를 문자열로만
log.error("에러 발생: " + e.getMessage());  // 스택트레이스 유실!

// ✅ 올바른 패턴
log.info("주문 생성 완료 orderId={} userId={} amount={}", orderId, userId, amount);
log.error("주문 처리 실패 orderId={}", orderId, e);  // 예외 객체를 마지막 인자로

┌─────────┐     ┌──────────┐     ┌──────────────┐     ┌──────────┐
│ App      │────▶│ Filebeat │────▶│ Logstash     │────▶│ Elastic  │
│ (JSON)   │     │ /FluentBit│    │ (파싱/변환)   │     │ Search   │
└─────────┘     └──────────┘     └──────────────┘     └──────────┘
                                                             │
                                                       ┌──────────┐
                                                       │ Kibana   │
                                                       │ (검색/시각화)│
                                                       └──────────┘

App (JSON) → Promtail → Grafana Loki → Grafana
# Elasticsearch 대비 저장 비용 1/10, 인덱싱 오버헤드 없음
# 단점: 풀텍스트 검색 불가, 레이블 기반 필터링만

// build.gradle
implementation 'org.springframework.boot:spring-boot-starter-actuator'
implementation 'io.micrometer:micrometer-registry-prometheus'

management:
  endpoints:
    web:
      exposure:
        include: health, info, prometheus  # 필요한 것만 노출!
      base-path: /internal/actuator       # 기본 /actuator 대신 내부 경로
  endpoint:
    health:
      show-details: when-authorized       # 인증된 사용자만 상세 정보
    prometheus:
      enabled: true
  metrics:
    tags:
      application: ${spring.application.name}
      environment: ${spring.profiles.active:local}
    distribution:
      percentiles-histogram:
        http.server.requests: true         # 히스토그램 활성화 → p50/p95/p99 계산
      slo:
        http.server.requests: 50ms, 100ms, 200ms, 500ms, 1s  # SLO 버킷

@Configuration
@EnableWebSecurity
public class ActuatorSecurityConfig {
    @Bean
    public SecurityFilterChain actuatorSecurity(HttpSecurity http) throws Exception {
        return http
            .securityMatcher("/internal/actuator/**")
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/internal/actuator/health").permitAll()
                .requestMatchers("/internal/actuator/prometheus").hasIpAddress("10.0.0.0/8")
                .anyRequest().authenticated()
            )
            .build();
    }
}

@Service
@RequiredArgsConstructor
public class OrderService {
    private final MeterRegistry meterRegistry;
    private final Counter orderSuccessCounter;
    private final Counter orderFailCounter;
    
    public OrderService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.orderSuccessCounter = Counter.builder("order.created")
            .tag("status", "success")
            .description("성공한 주문 수")
            .register(meterRegistry);
        this.orderFailCounter = Counter.builder("order.created")
            .tag("status", "fail")
            .description("실패한 주문 수")
            .register(meterRegistry);
    }
    
    public Order createOrder(OrderRequest request) {
        Timer.Sample sample = Timer.start(meterRegistry);
        try {
            Order order = processOrder(request);
            orderSuccessCounter.increment();
            // 주문 금액 분포 기록
            DistributionSummary.builder("order.amount")
                .baseUnit("won")
                .register(meterRegistry)
                .record(order.getTotalAmount());
            return order;
        } catch (Exception e) {
            orderFailCounter.increment();
            throw e;
        } finally {
            sample.stop(Timer.builder("order.processing.time")
                .description("주문 처리 소요 시간")
                .register(meterRegistry));
        }
    }
}

# 1. HTTP 요청 에러율 (5분 기준)
sum(rate(http_server_requests_seconds_count{status=~"5.."}[5m]))
/ sum(rate(http_server_requests_seconds_count[5m]))

# 2. p95 응답 시간
histogram_quantile(0.95, sum(rate(http_server_requests_seconds_bucket[5m])) by (le, uri))

# 3. 분당 주문 수
sum(rate(order_created_total{status="success"}[1m])) * 60

# 4. HikariCP 커넥션 풀 사용률 (포화도)
hikaricp_connections_active / hikaricp_connections_max

# 5. JVM 힙 메모리 사용률
jvm_memory_used_bytes{area="heap"} / jvm_memory_max_bytes{area="heap"}

// ❌ 절대 하지 말 것: 무한 카디널리티 label
meterRegistry.counter("api.request", "userId", userId);  
// userId가 100만이면 → 시계열 100만 개 → Prometheus OOM

// ❌ 위험: URL 경로를 그대로 label로
// /users/123, /users/456 → 무한 시계열

// ✅ 올바른 방법: 템플릿 경로 사용
meterRegistry.counter("api.request", "uri", "/users/{id}", "method", "GET");

Trace (traceId: abc123)
├── Span 1: API Gateway      [0ms ─────── 250ms]
│   ├── Span 2: OrderService  [10ms ──── 200ms]
│   │   ├── Span 3: DB Query  [20ms ─ 80ms]     ← 60ms
│   │   └── Span 4: Redis     [85ms ─ 90ms]     ← 5ms
│   └── Span 5: PaymentAPI    [205ms ── 240ms]  ← 35ms (외부 호출)

// build.gradle
implementation 'io.micrometer:micrometer-tracing-bridge-otel'
implementation 'io.opentelemetry:opentelemetry-exporter-otlp'

# application.yml
management:
  tracing:
    sampling:
      probability: 0.1  # 10% 샘플링 (프로덕션 권장)
  otlp:
    tracing:
      endpoint: http://otel-collector:4318/v1/traces

@Service
public class InventoryService {
    private final Tracer tracer;
    
    public boolean checkStock(Long productId, int quantity) {
        Span span = tracer.nextSpan().name("inventory.checkStock").start();
        try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
            span.tag("productId", String.valueOf(productId));
            span.tag("requestedQty", String.valueOf(quantity));
            
            boolean available = inventoryRepository.checkAvailability(productId, quantity);
            span.tag("available", String.valueOf(available));
            
            if (!available) {
                span.event("stock_insufficient");  // 이벤트 기록
            }
            return available;
        } catch (Exception e) {
            span.error(e);
            throw e;
        } finally {
            span.end();
        }
    }
}

1. 알람 발생: "주문 API p99 > 2초"
   └─ Prometheus 대시보드에서 확인

2. 언제부터?: 메트릭 그래프에서 시점 확인
   └─ 14:23부터 급증

3. 어떤 요청?: 트레이스에서 느린 요청 검색
   └─ Jaeger: service=order-service, minDuration=2s
   └─ traceId: abc123def456 발견

4. 무엇이 원인?: 트레이스 스팬 분석
   └─ DB 쿼리 스팬이 1.8초 (전체 2초 중 90%)

5. 상세 로그 확인: traceId로 필터링
   └─ Kibana: traceId="abc123def456"
   └─ "Slow query: SELECT * FROM orders WHERE ... (1823ms)"

6. 근본 원인: 인덱스 누락 → 풀 테이블 스캔

# Prometheus Exemplar 설정 (Grafana에서 메트릭 → 트레이스 연결)
management:
  metrics:
    distribution:
      percentiles-histogram:
        http.server.requests: true
  tracing:
    sampling:
      probability: 1.0  # exemplar를 위해 높은 샘플링 필요

월간 로그 볼륨 = 서비스 수 × 인스턴스 수 × 요청/초 × 로그 줄/요청 × 평균 바이트/줄 × 86400 × 30

예시: 5개 서비스 × 3 인스턴스 × 100 RPS × 3줄 × 200B × 86400 × 30
    = 약 2.3TB/월