OpenTelemetry Cheat Sheet

Trace: User checkout request
  +-- Span: HTTP GET /checkout (gateway)
       +-- Span: authenticate_user
       +-- Span: get_cart_items
       |    +-- Span: SELECT * FROM cart (database)
       +-- Span: process_payment
            +-- Span: POST /api/payment (external API)

# requirements.txt: opentelemetry-api, opentelemetry-sdk,
# opentelemetry-exporter-otlp
 
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.resources import Resource
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
 
# Konfigurasi resource (identitas service)
resource = Resource.create({
    "service.name": "checkout-service",
    "service.version": "1.0.0",
    "deployment.environment": "production",
})
 
# Setup tracer provider
provider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(
    OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)
)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)
 
# Ambil tracer
tracer = trace.get_tracer(__name__)

from opentelemetry import trace
 
tracer = trace.get_tracer(__name__)
 
# Cara 1: context manager
with tracer.start_as_current_span("process_order") as span:
    span.set_attribute("order.id", "12345")
    span.set_attribute("order.amount", 99.99)
    # Kode yang di trace
    result = do_work()
 
# Cara 2: manual start dan end
span = tracer.start_span("calculate_total")
try:
    span.set_attribute("items.count", 5)
    total = calculate(items)
    span.set_attribute("total.amount", total)
    span.set_status(trace.Status(trace.StatusCode.OK))
except Exception as e:
    span.record_exception(e)
    span.set_status(trace.Status(trace.StatusCode.ERROR, str(e)))
finally:
    span.end()

with tracer.start_as_current_span("database_query") as span:
    # Attributes: metadata key-value
    span.set_attribute("db.system", "postgresql")
    span.set_attribute("db.statement", "SELECT * FROM users WHERE id = $1")
    span.set_attribute("db.operation", "SELECT")
    span.set_attribute("net.peer.name", "db.example.com")
 
    # Events: log dalam span
    span.add_event("Query started", {
        "query.id": "q_001",
        "timestamp": "2024-01-01T10:00:00Z"
    })
 
    result = execute_query()
 
    span.add_event("Query completed", {
        "rows_returned": len(result)
    })

def handle_request():
    with tracer.start_as_current_span("handle_request") as parent:
        # Span ini otomatis menjadi child dari "handle_request"
        authenticate()
 
        # Span ini juga child dari "handle_request"
        process_data()
 
def authenticate():
    with tracer.start_as_current_span("authenticate"):
        # Span "authenticate" adalah child dari "handle_request"
        verify_token()
 
def verify_token():
    with tracer.start_as_current_span("verify_token"):
        # Span "verify_token" adalah child dari "authenticate"
        pass

// npm install @opentelemetry/api @opentelemetry/sdk-node
// @opentelemetry/exporter-trace-otlp-grpc
 
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-grpc');
const { Resource } = require('@opentelemetry/resources');
const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
 
const sdk = new NodeSDK({
  resource: new Resource({
    [SemanticResourceAttributes.SERVICE_NAME]: 'checkout-service',
    [SemanticResourceAttributes.SERVICE_VERSION]: '1.0.0',
  }),
  traceExporter: new OTLPTraceExporter({
    url: 'http://localhost:4317',
  }),
});
 
sdk.start();
 
// Graceful shutdown
process.on('SIGTERM', () => {
  sdk.shutdown()
    .then(() => console.log('Tracing terminated'))
    .catch((error) => console.error('Error terminating tracing', error))
    .finally(() => process.exit(0));
});

const opentelemetry = require('@opentelemetry/api');
const tracer = opentelemetry.trace.getTracer('my-app');
 
// Cara 1: manual
const span = tracer.startSpan('process_order');
span.setAttribute('order.id', '12345');
span.setAttribute('order.amount', 99.99);
 
try {
  opentelemetry.context.with(
    opentelemetry.trace.setSpan(opentelemetry.context.active(), span),
    () => {
      const result = doWork();
      span.addEvent('Order processed', { 'result.status': 'success' });
    }
  );
  span.setStatus({ code: opentelemetry.SpanStatusCode.OK });
} catch (error) {
  span.recordException(error);
  span.setStatus({
    code: opentelemetry.SpanStatusCode.ERROR,
    message: error.message,
  });
} finally {
  span.end();
}
 
// Cara 2: helper function
async function tracedOperation(name, fn, attributes = {}) {
  return tracer.startActiveSpan(name, async (span) => {
    Object.entries(attributes).forEach(([key, value]) => {
      span.setAttribute(key, value);
    });
    try {
      const result = await fn();
      span.setStatus({ code: opentelemetry.SpanStatusCode.OK });
      return result;
    } catch (error) {
      span.recordException(error);
      span.setStatus({
        code: opentelemetry.SpanStatusCode.ERROR,
        message: error.message,
      });
      throw error;
    } finally {
      span.end();
    }
  });
}
 
// Penggunaan
await tracedOperation('fetch_user', async () => {
  const response = await fetch('https://api.example.com/user/123');
  return response.json();
}, { 'user.id': '123' });

# Install instrumentation packages
pip install opentelemetry-distro
opentelemetry-bootstrap -a install
 
# Jalankan aplikasi dengan auto-instrumentation
opentelemetry-instrument \
  --service_name checkout-service \
  --exporter_otlp_endpoint http://localhost:4317 \
  --resource_attributes deployment.environment=production \
  python app.py

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
 
const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({ url: 'http://localhost:4317' }),
  instrumentations: [getNodeAutoInstrumentations({
    // Nonaktifkan instrumentation tertentu
    '@opentelemetry/instrumentation-fs': { enabled: false },
  })],
});
 
sdk.start();
 
// Jalankan dengan: node -r ./tracing.js app.js

traceparent: 00-{trace-id}-{span-id}-{trace-flags}

traceparent: 00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01

from opentelemetry import trace, propagate
from opentelemetry.propagators.composite import CompositePropagator
 
# Inject context ke headers (di sisi client)
headers = {}
propagate.inject(headers)
# headers sekarang berisi traceparent, tracestate, dll
 
# Kirim headers ke service berikutnya
response = requests.post("https://api.example.com/data", headers=headers)
 
# Extract context dari headers (di sisi server)
context = propagate.extract(request_headers)
# Lanjutkan trace dengan context ini

from opentelemetry.propagate import set_global_textmap
from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
from opentelemetry.baggage.propagation import W3CBaggagePropagator
 
# Composite propagator (W3C TraceContext + Baggage)
set_global_textmap(CompositePropagator([
    TraceContextTextMapPropagator(),
    W3CBaggagePropagator(),
]))

from opentelemetry import baggage
 
# Set baggage di service A
ctx = baggage.set_baggage("user.id", "user_123")
ctx = baggage.set_baggage("tenant.id", "acme_corp", context=ctx)
ctx = baggage.set_baggage("feature.beta", "true", context=ctx)
 
# Propagate context ini ke panggilan berikutnya
# Baggage otomatis ikut lewat header otel-baggage (atau baggage)
 
# Di service B, baca baggage
user_id = baggage.get_baggage("user.id")  # "user_123"
tenant_id = baggage.get_baggage("tenant.id")  # "acme_corp"

baggage: user.id=user_123,tenant.id=acme_corp,feature.beta=true

from opentelemetry import trace, baggage
 
with tracer.start_as_current_span("handle_request") as span:
    # Copy semua baggage ke span attributes untuk visibility
    entries = baggage.get_all()
    for key, value in entries.items():
        span.set_attribute(f"baggage.{key}", value)

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
 
# Setup meter provider
exporter = OTLPMetricExporter(endpoint="http://localhost:4317", insecure=True)
reader = PeriodicExportingMetricReader(exporter, export_interval_millis=10000)
provider = MeterProvider(metric_readers=[reader])
metrics.set_meter_provider(provider)
 
meter = metrics.get_meter("my-app", "1.0.0")
 
# Counter: monotonically increasing
request_counter = meter.create_counter(
    name="http_requests_total",
    description="Total HTTP requests",
    unit="1"
)
 
# Penggunaan
request_counter.add(1, {"http.method": "GET", "http.status": "200"})

# Histogram: ukur distribusi latency
request_duration = meter.create_histogram(
    name="http_request_duration_seconds",
    description="HTTP request duration in seconds",
    unit="s"
)
 
# Record latency
request_duration.record(0.142, {"http.method": "GET", "http.route": "/api/users"})
 
# Observable Gauge: laporkan nilai sesaat
import psutil
 
def cpu_usage_callback(options):
    yield metrics.Observation(psutil.cpu_percent() / 100, {"host": "server-01"})
 
meter.create_observable_gauge(
    name="system_cpu_usage",
    callbacks=[cpu_usage_callback],
    description="CPU usage ratio",
    unit="1"
)

import logging
from opentelemetry import trace
from opentelemetry._logs import set_logger_provider
from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 
# Setup logger provider
logger_provider = LoggerProvider()
set_logger_provider(logger_provider)
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(OTLPLogExporter(endpoint="http://localhost:4317", insecure=True))
)
 
# Attach ke Python logging
handler = LoggingHandler(level=logging.INFO)
logging.getLogger().addHandler(handler)
 
# Sekarang log otomatis dikirim ke OTel backend dengan trace context
logger = logging.getLogger(__name__)
 
with tracer.start_as_current_span("checkout"):
    logger.info("Processing checkout", extra={"order.id": "12345"})
    # Log ini otomatis dikaitkan dengan span "checkout"

App --OTLP--> Collector --OTLP--> Jaeger
                          --OTLP--> Tempo
                          --OTLP--> Prometheus
                          --OTLP--> Datadog

# otel-collector-config.yaml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318
 
processors:
  batch:
    timeout: 5s
    send_batch_size: 1000
  memory_limiter:
    check_interval: 1s
    limit_mib: 512
  filter:
    error_mode: ignore
    traces:
      span:
        - 'attributes["http.route"] == "/health"'
  resource:
    attributes:
      - key: deployment.environment
        value: production
        action: upsert
 
exporters:
  otlp/jaeger:
    endpoint: jaeger:4317
    tls:
      insecure: true
  prometheus:
    endpoint: 0.0.0.0:8889
  loki:
    endpoint: http://loki:3100/loki/api/v1/push
 
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, batch, filter]
      exporters: [otlp/jaeger]
    metrics:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [prometheus]
    logs:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [loki]

docker run -p 4317:4317 -p 4318:4318 \
  -v $(pwd)/otel-collector-config.yaml:/etc/otelcol/config.yaml \
  otel/opentelemetry-collector-contrib:latest

# Jalankan Jaeger all-in-one untuk development
docker run -d --name jaeger \
  -p 16686:16686 \
  -p 4317:4317 \
  -p 4318:4318 \
  jaegertracing/all-in-one:latest
 
# UI tersedia di http://localhost:16686

# tempo.yaml (minimal config)
server:
  http_listen_port: 3200
distributor:
  receivers:
    otlp:
      protocols:
        grpc:
          endpoint: 0.0.0.0:4317
storage:
  trace:
    backend: local
    local:
      path: /tmp/tempo/blocks

docker run -d -p 3200:3200 -p 4317:4317 \
  -v $(pwd)/tempo.yaml:/etc/tempo.yaml \
  grafana/tempo:latest -config.file=/etc/tempo.yaml

from opentelemetry.sdk.trace.sampling import (
    TraceIdRatioBased, ParentBased, ALWAYS_ON
)
 
sampler = ParentBased(root=TraceIdRatioBased(rate=0.1))  # 10% sampling
provider = TracerProvider(resource=resource, sampler=sampler)