Source: Dev.to

2026년 관측 가능성: 분산 트레이싱이 로그를 대체하고 OpenTelemetry가 승리했다

2026년의 관측 가능성 풍경은 2020년과 전혀 다릅니다. 로그는 이제 부차적인 존재가 되었고, 트레이스가 핵심이 되었습니다. 그리고 OpenTelemetry(OTel)는 계측 전쟁에서 압도적으로 승리해 “벤더 중립 관측 가능성”이라는 표현 자체가 불필요할 정도가 되었습니다. 어떤 변화가 있었는지 살펴보겠습니다.

2020년, 디버깅은 로그였다

# The old way
logger.info(f"Processing order {order_id} for user {user_id}")
logger.info(f"Payment processing for ${amount}")
logger.error(f"Payment failed: {error_code}")

# Debugging a production issue:
# 1. Find the right log lines across 50 service logs
# 2. Correlate timestamps across machines (which may not be synced)
# 3. Reconstruct what happened from thousands of log lines
# 4. Hope the relevant lines weren't filtered out by your logging library

마이크로서비스 환경에서는 이 방식이 무너지기 시작했습니다. 하나의 사용자 요청이 20개의 서비스에 걸쳐 전파되는데, 서로 다른 타임스탬프를 가진 20개의 로그를 연관시키는 일은 고고학에 가깝고 엔지니어링이라 부르기 어렵습니다.

새로운 방식: OpenTelemetry

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

# Set up the tracer
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
    BatchSpanProcessor(OTLPSpanExporter())
)
tracer = trace.get_tracer(__name__)

# Instrument your code
def process_order(order_id: str, user_id: str, amount: float):
    with tracer.start_as_current_span("process_order") as span:
        span.set_attribute("order.id", order_id)
        span.set_attribute("user.id", user_id)
        span.set_attribute("order.amount", amount)

        with tracer.start_as_current_span("validate_order"):
            # validation logic
            pass

        with tracer.start_as_current_span("process_payment") as payment_span:
            payment_span.set_attribute("payment.method", "stripe")
            result = stripe.charge(amount)
            payment_span.set_attribute("payment.status", result.status)

            with tracer.start_as_current_span("send_confirmation"):
                send_email(user_id, result)

관측 플랫폼을 열어보면 다음과 같은 트레이스를 확인할 수 있습니다.

process_order (2.3s)
├── validate_order (0.1s)
├── process_payment (2.1s)
│   ├── stripe.charge (1.8s)
│   └── send_confirmation (0.3s)

하나의 트레이스, 모든 서비스, 완전한 지연 시간 분해. 로그 고고학은 사라졌습니다.

OpenTelemetry는 이제 보편적인 계측 표준

주요 관측 플랫폼 모두가 OpenTelemetry를 지원합니다.

• Datadog ✓
• Honeycomb ✓
• Grafana Tempo ✓
• Jaeger ✓
• New Relic ✓
• AWS X‑Ray ✓
• Google Cloud Trace ✓

# otel-collector-config.yaml
receivers:
  otlp:
    protocols:
      grpc:
      http:

processors:
  batch:
    timeout: 5s
    send_batch_size: 1024

  memory_limiter:
    check_interval: 1s
    limit_mib: 4000

exporters:
  otlp/tempo:
    endpoint: tempo:4317
    tls:
      insecure: false

  datadog:
    api:
      key: ${DATADOG_API_KEY}

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [otlp/tempo, datadog]
    metrics:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [otlp/tempo, datadog]

2026년 가장 큰 승리: 자동 계측

코드를 수정하지 않아도 분산 트레이스를 바로 얻을 수 있습니다.

# Install the agent
pip install opentelemetry-instrumentation-all

# Run your app with auto-instrumentation
opentelemetry-instrument python your_app.py

자동 계측이 지원하는 대상

• HTTP 요청 (Flask, FastAPI, Django, aiohttp)
• 데이터베이스 호출 (psycopg2, SQLAlchemy, asyncpg)
• Redis, Memcached, Kafka
• gRPC, HTTPX

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-service
spec:
  template:
    spec:
      containers:
      - name: my-service
        image: my-service:latest
        env:
        - name: OTEL_SERVICE_NAME
          value: "my-service"
        - name: OTEL_EXPORTER_OTLP_ENDPOINT
          value: "http://otel-collector:4317"
        - name: OTEL_RESOURCE_ATTRIBUTES
          value: "deployment.environment=production"
        - name: OTEL_PROPAGATORS
          value: "tracecontext,baggage"
        - name: OTEL_TRACES_SAMPLER
          value: "parentbased_traceidratio"
        - name: OTEL_TRACES_SAMPLER_ARG
          value: "0.1"  # Sample 10% of traces

from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter

# Set up metrics
metric_reader = PeriodicExportingMetricReader(
    OTLPMetricExporter(), export_interval_millis=30000
)
metrics.set_meter_provider(MeterProvider(metric_readers=[metric_reader]))
meter = metrics.get_meter(__name__)

# Create metrics
order_counter = meter.create_counter(
    "orders_processed",
    description="Number of orders processed",
    unit="1"
)

payment_duration = meter.create_histogram(
    "payment_duration",
    description="Payment processing duration",
    unit="ms"
)

error_counter = meter.create_counter(
    "payment_errors",
    description="Number of payment errors"
)

# Use them
def process_payment(amount: float):
    with tracer.start_as_current_span("process_payment"):
        try:
            start = time.time()
            result = stripe.charge(amount)
            payment_duration.record((time.time() - start) * 1000)
            order_counter.add(1, {"status": "success"})
            return result
        except Exception as e:
            error_counter.add(1, {"error": type(e).__name__})
            raise

import structlog

structlog.configure(
    processors=[
        structlog.processors.TimeStamper