Prometheus PromQL 고급 쿼리와 Recording Rules 최적화: SLI/SLO 기반 알림 체계 구축 가이드

# 알림 규칙 - 반드시 rate() 사용
# rate()는 범위 전체의 평균이므로 일시적 스파이크에 안정적
sum(rate(http_requests_total{status=~"5.."}[5m])) by (service)
/
sum(rate(http_requests_total[5m])) by (service)

# 대시보드 시각화 - irate()로 실시간 반응성 확보
# $__rate_interval은 Grafana가 scrape interval 기반으로 자동 계산
sum(irate(http_requests_total{status=~"5.."}[$__rate_interval])) by (service)
/
sum(irate(http_requests_total[$__rate_interval])) by (service)

# rate()의 range window 선택 기준
# - scrape_interval의 최소 4배 이상 (15s interval이면 최소 [1m])
# - 알림용: [5m] 이상 권장 (데이터 포인트 누락에 대한 내성 확보)
# - 너무 넓으면 감지가 느려지고, 너무 좁으면 노이즈가 증가

# 서비스별 P99 응답 시간
histogram_quantile(0.99,
  sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service)
)

# 엔드포인트별 P95 응답 시간 (상위 레이블 추가)
histogram_quantile(0.95,
  sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service, endpoint)
)

# Apdex Score 계산 (만족: 0.5s 이하, 허용: 2s 이하)
(
  sum(rate(http_request_duration_seconds_bucket{le="0.5"}[5m])) by (service)
  +
  sum(rate(http_request_duration_seconds_bucket{le="2.0"}[5m])) by (service)
)
/ 2
/
sum(rate(http_request_duration_seconds_count[5m])) by (service)

# Native Histogram (Prometheus 2.53+) 활용
# 버킷 경계를 자동 관리하여 정확도와 효율성 모두 향상
histogram_quantile(0.99, sum(rate(http_request_duration_seconds[5m])) by (le, service))

# 디스크가 24시간 내에 고갈될 것으로 예측되면 알림
predict_linear(node_filesystem_avail_bytes{mountpoint="/"}[6h], 24 * 3600) < 0

# PVC 용량 예측 (Kubernetes)
predict_linear(
  kubelet_volume_stats_available_bytes[12h], 7 * 24 * 3600
) < 0

# 인증서 만료 예측 (cert-manager)
# 현재 남은 시간이 30일(2592000초) 미만이면 알림
(x509_cert_not_after - time()) < 2592000

# Prometheus TSDB 스토리지 증가율 예측
predict_linear(prometheus_tsdb_storage_blocks_bytes[7d], 30 * 24 * 3600)
  > prometheus_tsdb_retention_limit_bytes * 0.9

# Subquery: 지난 1시간 동안의 5분 에러율 최대값
max_over_time(
  (
    sum(rate(http_requests_total{status=~"5.."}[5m])) by (service)
    /
    sum(rate(http_requests_total[5m])) by (service)
  )[1h:1m]
)

# offset을 활용한 전주 대비 트래픽 비교
sum(rate(http_requests_total[5m])) by (service)
/
sum(rate(http_requests_total[5m] offset 7d)) by (service)

# label_replace()로 레이블 가공
label_replace(
  up{job="prometheus"},
  "cluster", "$1", "instance", "(.+)\\.example\\.com:.*"
)

# absent()로 메트릭 수집 중단 감지
absent(up{job="payment-service"} == 1)

# prometheus/recording_rules.yaml
groups:
  # 그룹명은 논리적 단위로 구분 (파일당 1-3개 그룹이 적정)
  - name: http_request_rates
    # interval: 평가 주기 (생략 시 global.evaluation_interval 사용)
    # SLI용 Recording Rules는 30초 이하 권장
    interval: 30s
    rules:
      # 서비스별 초당 총 요청 수
      - record: service:http_requests:rate5m
        expr: |
          sum(rate(http_requests_total[5m])) by (service)

      # 서비스별 초당 에러 요청 수
      - record: service:http_requests_errors:rate5m
        expr: |
          sum(rate(http_requests_total{status=~"5.."}[5m])) by (service)

      # 서비스별 에러율
      - record: service:http_error_rate:ratio_rate5m
        expr: |
          service:http_requests_errors:rate5m
          /
          service:http_requests:rate5m

      # 서비스별 P99 응답 시간
      - record: service:http_request_duration_seconds:p99_rate5m
        expr: |
          histogram_quantile(0.99,
            sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service)
          )

      # 서비스별 P95 응답 시간
      - record: service:http_request_duration_seconds:p95_rate5m
        expr: |
          histogram_quantile(0.95,
            sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service)
          )

level:metric:operations

level      - 집계 수준 (어떤 레이블 차원이 남아있는가)
metric     - 원본 메트릭 이름
operations - 적용된 연산 (rate, ratio, p99 등)

# level = "job" (job 레이블 기준 집계)
# metric = "http_requests" (원본: http_requests_total)
# operation = "rate5m" (5분 rate 적용)
- record: job:http_requests:rate5m
  expr: sum(rate(http_requests_total[5m])) by (job)

# level = "cluster" (클러스터 전체 집계, 레이블 없음)
# metric = "http_requests"
# operation = "rate5m"
- record: cluster:http_requests:rate5m
  expr: sum(rate(http_requests_total[5m]))

# level = "service" + "endpoint"
# metric = "http_request_duration_seconds"
# operation = "p99_rate5m"
- record: service_endpoint:http_request_duration_seconds:p99_rate5m
  expr: |
    histogram_quantile(0.99,
      sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service, endpoint)
    )

# SLI용 Recording Rule
# level = "service"
# metric = "sli_availability"
# operation = "ratio_rate5m"
- record: service:sli_availability:ratio_rate5m
  expr: |
    sum(rate(http_requests_total{status!~"5.."}[5m])) by (service)
    /
    sum(rate(http_requests_total[5m])) by (service)

# 복합 연산: ratio(비율)를 나타내는 Recording Rule
# "ratio"가 operation에 포함되면 0-1 범위의 비율 값임을 명시
- record: instance:node_cpu:utilization_ratio
  expr: |
    1 - avg without(cpu, mode)(
      rate(node_cpu_seconds_total{mode="idle"}[5m])
    )

# prometheus/sli_recording_rules.yaml
groups:
  - name: sli_definitions
    interval: 30s
    rules:
      # === 가용성(Availability) SLI ===
      # "좋은 요청" = 5xx가 아닌 모든 응답
      # 4xx는 클라이언트 오류이므로 서버 가용성에서 제외하지 않음
      - record: service:sli_availability:ratio_rate5m
        expr: |
          sum(rate(http_requests_total{status!~"5.."}[5m])) by (service)
          /
          sum(rate(http_requests_total[5m])) by (service)

      # === 지연시간(Latency) SLI ===
      # "좋은 요청" = 300ms 이내에 응답된 요청
      - record: service:sli_latency:ratio_rate5m
        expr: |
          sum(rate(http_request_duration_seconds_bucket{le="0.3"}[5m])) by (service)
          /
          sum(rate(http_request_duration_seconds_count[5m])) by (service)

      # === 복합 SLI ===
      # "좋은 요청" = 5xx가 아니고 AND 300ms 이내에 응답
      # 가용성과 지연시간 SLI의 교집합
      - record: service:sli_combined:ratio_rate5m
        expr: |
          min without() (
            service:sli_availability:ratio_rate5m,
            service:sli_latency:ratio_rate5m
          )

      # === 30일 Rolling Window SLI ===
      # Error Budget 계산의 기준이 되는 장기 SLI
      - record: service:sli_availability:ratio_rate30d
        expr: |
          sum(rate(http_requests_total{status!~"5.."}[30d])) by (service)
          /
          sum(rate(http_requests_total[30d])) by (service)

      # === Error Budget 잔량 (퍼센트) ===
      # SLO 99.9% 기준, 남은 error budget 비율
      - record: service:error_budget_remaining:ratio
        expr: |
          1 - (
            (1 - service:sli_availability:ratio_rate30d)
            /
            (1 - 0.999)
          )

# prometheus/slo_alerting_rules.yaml
groups:
  - name: slo_burn_rate_alerts
    rules:
      # ============================================================
      # SLO: 가용성 99.9% (30일 윈도우)
      # Error Budget = 0.1% = 43.2분/30일
      # ============================================================

      # --- Critical: Burn Rate 14.4, 1h/5m 윈도우 ---
      # 이 속도면 약 2일 만에 월간 error budget 전량 소진
      - alert: SLOAvailabilityBurnRateCritical
        expr: |
          (
            1 - (sum(rate(http_requests_total{status!~"5.."}[1h])) by (service)
                 / sum(rate(http_requests_total[1h])) by (service))
          ) > (14.4 * 0.001)
          and
          (
            1 - (sum(rate(http_requests_total{status!~"5.."}[5m])) by (service)
                 / sum(rate(http_requests_total[5m])) by (service))
          ) > (14.4 * 0.001)
        for: 2m
        labels:
          severity: critical
          slo_type: availability
          burn_rate: '14.4'
          alert_window: '1h/5m'
        annotations:
          summary: >-
            {{ $labels.service }}: 가용성 SLO burn rate critical (14.4x)
          description: >-
            서비스 {{ $labels.service }}의 에러율이 SLO(99.9%) 대비
            14.4배 속도로 error budget을 소진 중입니다.
            약 2일 내에 전체 월간 budget이 소진됩니다. 즉시 확인하세요.
          runbook_url: https://wiki.internal/runbook/slo-critical
          dashboard_url: >-
            https://grafana.internal/d/slo-overview?var-service={{ $labels.service }}

      # --- Warning: Burn Rate 6, 6h/30m 윈도우 ---
      - alert: SLOAvailabilityBurnRateHigh
        expr: |
          (
            1 - (sum(rate(http_requests_total{status!~"5.."}[6h])) by (service)
                 / sum(rate(http_requests_total[6h])) by (service))
          ) > (6 * 0.001)
          and
          (
            1 - (sum(rate(http_requests_total{status!~"5.."}[30m])) by (service)
                 / sum(rate(http_requests_total[30m])) by (service))
          ) > (6 * 0.001)
        for: 5m
        labels:
          severity: warning
          slo_type: availability
          burn_rate: '6'
          alert_window: '6h/30m'
        annotations:
          summary: >-
            {{ $labels.service }}: 가용성 SLO burn rate high (6x)
          description: >-
            서비스 {{ $labels.service }}의 에러율이 SLO(99.9%) 대비
            6배 속도로 error budget을 소진 중입니다.
            약 5일 내에 전체 budget이 소진됩니다.

      # --- Info: Burn Rate 2, 3d/6h 윈도우 ---
      - alert: SLOAvailabilityBurnRateSlow
        expr: |
          (
            1 - (sum(rate(http_requests_total{status!~"5.."}[3d])) by (service)
                 / sum(rate(http_requests_total[3d])) by (service))
          ) > (2 * 0.001)
          and
          (
            1 - (sum(rate(http_requests_total{status!~"5.."}[6h])) by (service)
                 / sum(rate(http_requests_total[6h])) by (service))
          ) > (2 * 0.001)
        for: 30m
        labels:
          severity: info
          slo_type: availability
          burn_rate: '2'
          alert_window: '3d/6h'
        annotations:
          summary: >-
            {{ $labels.service }}: 가용성 SLO burn rate elevated (2x)
          description: >-
            서비스 {{ $labels.service }}의 에러율이 SLO 대비
            2배 속도로 error budget을 소진 중입니다.
            약 15일 내에 budget이 소진되며, 주간 리뷰에서 확인이 필요합니다.

      # ============================================================
      # SLO: 지연시간 (P99 < 300ms) 99.9% (30일 윈도우)
      # ============================================================

      - alert: SLOLatencyBurnRateCritical
        expr: |
          (
            1 - (sum(rate(http_request_duration_seconds_bucket{le="0.3"}[1h])) by (service)
                 / sum(rate(http_request_duration_seconds_count[1h])) by (service))
          ) > (14.4 * 0.001)
          and
          (
            1 - (sum(rate(http_request_duration_seconds_bucket{le="0.3"}[5m])) by (service)
                 / sum(rate(http_request_duration_seconds_count[5m])) by (service))
          ) > (14.4 * 0.001)
        for: 2m
        labels:
          severity: critical
          slo_type: latency
          burn_rate: '14.4'
        annotations:
          summary: >-
            {{ $labels.service }}: 지연시간 SLO burn rate critical (14.4x)
          description: >-
            서비스 {{ $labels.service }}의 P99 응답시간이 300ms SLO를 위반하는
            비율이 14.4배 속도로 error budget을 소진 중입니다.

# prometheus/slo_recording_rules.yaml
groups:
  - name: slo_error_rates
    interval: 30s
    rules:
      # 각 윈도우별 에러율을 Recording Rule로 사전 계산
      - record: service:http_error_rate:ratio_rate5m
        expr: |
          1 - (sum(rate(http_requests_total{status!~"5.."}[5m])) by (service)
               / sum(rate(http_requests_total[5m])) by (service))

      - record: service:http_error_rate:ratio_rate30m
        expr: |
          1 - (sum(rate(http_requests_total{status!~"5.."}[30m])) by (service)
               / sum(rate(http_requests_total[30m])) by (service))

      - record: service:http_error_rate:ratio_rate1h
        expr: |
          1 - (sum(rate(http_requests_total{status!~"5.."}[1h])) by (service)
               / sum(rate(http_requests_total[1h])) by (service))

      - record: service:http_error_rate:ratio_rate6h
        expr: |
          1 - (sum(rate(http_requests_total{status!~"5.."}[6h])) by (service)
               / sum(rate(http_requests_total[6h])) by (service))

      - record: service:http_error_rate:ratio_rate3d
        expr: |
          1 - (sum(rate(http_requests_total{status!~"5.."}[3d])) by (service)
               / sum(rate(http_requests_total[3d])) by (service))

  - name: slo_alerts_optimized
    rules:
      # Recording Rules를 참조하여 알림 규칙을 간결하고 효율적으로 작성
      - alert: SLOAvailabilityBurnRateCritical
        expr: |
          service:http_error_rate:ratio_rate1h > (14.4 * 0.001)
            and
          service:http_error_rate:ratio_rate5m > (14.4 * 0.001)
        for: 2m
        labels:
          severity: critical
          slo_type: availability
          burn_rate: '14.4'

      - alert: SLOAvailabilityBurnRateHigh
        expr: |
          service:http_error_rate:ratio_rate6h > (6 * 0.001)
            and
          service:http_error_rate:ratio_rate30m > (6 * 0.001)
        for: 5m
        labels:
          severity: warning
          slo_type: availability
          burn_rate: '6'

# alertmanager/alertmanager.yml
global:
  resolve_timeout: 5m
  slack_api_url: 'https://hooks.slack.com/services/T00/B00/XXXX'

# 알림 수신 시 라우팅 트리를 순회하며 매칭되는 수신자에게 전달
route:
  # 기본 그룹핑: 서비스와 SLO 타입별로 묶음
  group_by: ['service', 'slo_type', 'alertname']
  # 첫 알림 대기 시간 (동일 그룹의 알림을 모아서 발송)
  group_wait: 30s
  # 같은 그룹에 새 알림 추가 시 재발송 간격
  group_interval: 5m
  # 동일 알림 반복 발송 간격
  repeat_interval: 4h
  # 기본 수신자
  receiver: 'slack-default'

  routes:
    # Critical: PagerDuty + Slack (즉시 대응 필요)
    - match:
        severity: critical
      receiver: 'pagerduty-critical'
      group_wait: 10s
      repeat_interval: 1h
      continue: true # 다음 라우트도 계속 평가

    - match:
        severity: critical
      receiver: 'slack-critical'
      group_wait: 10s

    # Warning: Slack 전용 채널 (업무 시간 내 대응)
    - match:
        severity: warning
      receiver: 'slack-warning'
      repeat_interval: 8h

    # Info: 주간 다이제스트로 수집 (즉시 대응 불필요)
    - match:
        severity: info
      receiver: 'slack-info'
      repeat_interval: 24h

    # 특정 서비스를 담당 팀 채널로 라우팅
    - match_re:
        service: 'payment-.*'
      receiver: 'slack-payment-team'
      routes:
        - match:
            severity: critical
          receiver: 'pagerduty-payment'

# Inhibition: 상위 severity 알림이 활성 상태면 하위 알림 억제
inhibit_rules:
  - source_match:
      severity: critical
    target_match:
      severity: warning
    equal: ['service', 'slo_type']

  - source_match:
      severity: critical
    target_match:
      severity: info
    equal: ['service', 'slo_type']

receivers:
  - name: 'pagerduty-critical'
    pagerduty_configs:
      - service_key: '<PAGERDUTY_SERVICE_KEY>'
        severity: critical
        description: '{{ .GroupLabels.service }}: {{ .CommonAnnotations.summary }}'
        details:
          firing: '{{ .Alerts.Firing | len }}'
          dashboard: '{{ (index .Alerts 0).Annotations.dashboard_url }}'
          runbook: '{{ (index .Alerts 0).Annotations.runbook_url }}'

  - name: 'slack-critical'
    slack_configs:
      - channel: '#alerts-critical'
        send_resolved: true
        title: '{{ .Status | toUpper }}: {{ .GroupLabels.service }}'
        text: >-
          {{ range .Alerts }}
          *{{ .Annotations.summary }}*
          {{ .Annotations.description }}
          {{ end }}

  - name: 'slack-warning'
    slack_configs:
      - channel: '#alerts-warning'
        send_resolved: true

  - name: 'slack-info'
    slack_configs:
      - channel: '#alerts-info'
        send_resolved: false

  - name: 'slack-default'
    slack_configs:
      - channel: '#alerts-default'

  - name: 'slack-payment-team'
    slack_configs:
      - channel: '#team-payment-alerts'

  - name: 'pagerduty-payment'
    pagerduty_configs:
      - service_key: '<PAYMENT_PAGERDUTY_KEY>'

# TSDB 상태 확인 - 시계열 수가 가장 많은 메트릭 Top 10
topk(10, count by (__name__)({__name__=~".+"}))

# 특정 메트릭의 레이블별 카디널리티 확인
count(http_requests_total) by (method)
count(http_requests_total) by (status)
count(http_requests_total) by (handler)

# 전체 시계열 수 추이 (급증하면 문제의 징후)
prometheus_tsdb_head_series

# 메모리 사용량 추이
process_resident_memory_bytes{job="prometheus"}

# 고카디널리티 메트릭을 Recording Rules로 집계하여 카디널리티 감소
groups:
  - name: cardinality_reduction
    interval: 1m
    rules:
      # handler별로 수천 개의 시계열을 service 단위로 집계
      # handler 레이블을 제거하여 카디널리티를 1/100로 감소
      - record: service:http_requests:rate5m
        expr: |
          sum(rate(http_requests_total[5m])) by (service, method, status)

      # endpoint별 세분화된 히스토그램을 service 단위로 집계
      - record: service:http_request_duration_seconds_bucket:rate5m
        expr: |
          sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service)

# prometheus.yml - 성능 관련 설정
global:
  scrape_interval: 15s
  evaluation_interval: 15s
  # query_log_file로 느린 쿼리를 기록하여 최적화 대상 식별
  query_log_file: /prometheus/query.log

# Recording Rules 파일 로드
rule_files:
  - /etc/prometheus/recording_rules/*.yaml
  - /etc/prometheus/alerting_rules/*.yaml
# 쿼리 엔진 설정 (Prometheus 2.x 커맨드 라인 플래그)
# --query.max-concurrency=20       동시 쿼리 수 제한
# --query.timeout=2m               단일 쿼리 타임아웃
# --query.max-samples=50000000     단일 쿼리 최대 샘플 수
# --storage.tsdb.retention.time=30d 데이터 보존 기간
# --storage.tsdb.retention.size=100GB 데이터 보존 크기 제한

{
  "dashboard": {
    "title": "SLO Overview Dashboard",
    "panels": [
      {
        "title": "Service Availability (SLI)",
        "type": "gauge",
        "targets": [
          {
            "expr": "service:sli_availability:ratio_rate30d",
            "legendFormat": "{{ service }}"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "thresholds": {
              "steps": [
                { "value": 0, "color": "red" },
                { "value": 0.995, "color": "yellow" },
                { "value": 0.999, "color": "green" }
              ]
            },
            "min": 0.99,
            "max": 1,
            "unit": "percentunit"
          }
        }
      },
      {
        "title": "Error Budget Remaining",
        "type": "timeseries",
        "targets": [
          {
            "expr": "service:error_budget_remaining:ratio * 100",
            "legendFormat": "{{ service }}"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "unit": "percent",
            "thresholds": {
              "steps": [
                { "value": 0, "color": "red" },
                { "value": 20, "color": "orange" },
                { "value": 50, "color": "green" }
              ]
            }
          }
        }
      },
      {
        "title": "P99 Latency by Service",
        "type": "timeseries",
        "targets": [
          {
            "expr": "service:http_request_duration_seconds:p99_rate5m",
            "legendFormat": "{{ service }}"
          }
        ],
        "fieldConfig": {
          "defaults": {
            "unit": "s"
          }
        }
      }
    ]
  }
}

# Recording Rules 평가 지연 확인
prometheus_rule_group_duration_seconds{rule_group="slo_error_rates"}

# 평가 시간이 interval을 초과한 그룹 식별
prometheus_rule_group_duration_seconds > 15

# 규칙별 평가 실패 횟수
prometheus_rule_evaluation_failures_total

# 마지막 평가 시간 확인
prometheus_rule_group_last_duration_seconds

# 현재 PENDING 상태인 알림 확인
ALERTS{alertstate="pending"}

# 현재 FIRING 상태인 알림 확인
ALERTS{alertstate="firing"}

# Alertmanager 전송 실패 확인
prometheus_notifications_errors_total
prometheus_notifications_dropped_total

# 시계열 총 수 추이
prometheus_tsdb_head_series

# Recording Rules가 생성한 시계열 수
count({__name__=~".+:.+"})

# 메모리 사용량
process_resident_memory_bytes{job="prometheus"} / 1024 / 1024 / 1024

# 규칙 파일 문법 검증
promtool check rules /etc/prometheus/recording_rules/slo_rules.yaml

# Unit Test 실행
promtool test rules /etc/prometheus/tests/slo_rules_test.yaml

# 설정 전체 검증
promtool check config /etc/prometheus/prometheus.yml

# tests/slo_rules_test.yaml
rule_files:
  - ../recording_rules/slo_rules.yaml
  - ../alerting_rules/slo_alerts.yaml

evaluation_interval: 1m

tests:
  # Recording Rule 출력 값 검증
  - interval: 1m
    input_series:
      - series: 'http_requests_total{service="api", status="200"}'
        values: '0+100x10' # 분당 100씩 증가 (10분)
      - series: 'http_requests_total{service="api", status="500"}'
        values: '0+1x10' # 분당 1씩 증가 (10분)

    promql_expr_test:
      - expr: service:sli_availability:ratio_rate5m{service="api"}
        eval_time: 10m
        exp_samples:
          - labels: 'service:sli_availability:ratio_rate5m{service="api"}'
            value: 0.9901 # 100/(100+1) 근사값

    alert_rule_test:
      - eval_time: 10m
        alertname: SLOAvailabilityBurnRateCritical
        exp_alerts: [] # 이 수준의 에러율로는 critical 알림 발화 안 함