OpenTelemetry Logs [complete guide]

import (
    "go.uber.org/zap"
    "go.opentelemetry.io/otel/trace"
)

logger, _ := zap.NewProduction()

// Structured logging with trace context
func handleRequest(ctx context.Context) {
    span := trace.SpanFromContext(ctx)
    spanCtx := span.SpanContext()

    logger.Info("processing request",
        zap.String("trace_id", spanCtx.TraceID().String()),
        zap.String("span_id", spanCtx.SpanID().String()),
        zap.String("user.id", "12345"),
        zap.String("http.method", "GET"),
        zap.String("http.route", "/api/users/:id"),
        zap.Int("http.status_code", 200),
        zap.Duration("duration", 245*time.Millisecond),
    )
}

import structlog
from opentelemetry import trace

logger = structlog.get_logger()

def handle_request():
    span = trace.get_current_span()
    span_ctx = span.get_span_context()

    logger.info(
        "processing request",
        trace_id=format(span_ctx.trace_id, '032x'),
        span_id=format(span_ctx.span_id, '016x'),
        user_id="12345",
        http_method="GET",
        http_route="/api/users/:id",
        http_status_code=200,
        duration_ms=245
    )

const winston = require('winston');
const { trace } = require('@opentelemetry/api');

const logger = winston.createLogger({
  format: winston.format.json(),
  transports: [new winston.transports.Console()]
});

function handleRequest() {
  const span = trace.getActiveSpan();
  const spanCtx = span.spanContext();

  logger.info('processing request', {
    trace_id: spanCtx.traceId,
    span_id: spanCtx.spanId,
    user_id: '12345',
    http_method: 'GET',
    http_route: '/api/users/:id',
    http_status_code: 200,
    duration_ms: 245
  });
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import io.opentelemetry.api.trace.Span;

Logger logger = LoggerFactory.getLogger(MyClass.class);

public void handleRequest() {
    Span span = Span.current();
    SpanContext spanCtx = span.getSpanContext();

    // Add trace context to MDC
    MDC.put("trace_id", spanCtx.getTraceId());
    MDC.put("span_id", spanCtx.getSpanId());

    logger.info("Processing request user.id={} http.method={} duration={}ms",
        "12345", "GET", 245);

    MDC.clear();
}

import (
    "go.uber.org/zap"
    "go.opentelemetry.io/contrib/bridges/otelzap"
    "go.opentelemetry.io/otel"
)

// Create logger bridge
core := otelzap.NewCore("my-service")
logger := zap.New(core)

// Logs automatically include trace context
func handleRequest(ctx context.Context) {
    ctx, span := tracer.Start(ctx, "handle_request")
    defer span.End()

    // This log is automatically correlated with the span
    logger.Ctx(ctx).Info("processing started",
        zap.String("user.id", "12345"),
    )

    // Do work...

    logger.Ctx(ctx).Info("processing completed")
}

from opentelemetry import trace
from opentelemetry._logs import set_logger_provider
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
import logging

# Set up OpenTelemetry logging
logger_provider = LoggerProvider()
set_logger_provider(logger_provider)
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(exporter)
)

# Attach to Python logging
handler = LoggingHandler(logger_provider=logger_provider)
logging.getLogger().addHandler(handler)

# Logs automatically correlated
tracer = trace.get_tracer(__name__)

def handle_request():
    with tracer.start_as_current_span("handle_request"):
        # Automatically includes trace context
        logging.info("Processing started", extra={"user.id": "12345"})
        # Do work...
        logging.info("Processing completed")

const winston = require('winston');
const { trace, context } = require('@opentelemetry/api');

const logger = winston.createLogger({
  format: winston.format.combine(
    winston.format((info) => {
      const span = trace.getActiveSpan();
      if (span) {
        const spanContext = span.spanContext();
        info.trace_id = spanContext.traceId;
        info.span_id = spanContext.spanId;
        info.trace_flags = spanContext.traceFlags;
      }
      return info;
    })(),
    winston.format.json()
  ),
  transports: [new winston.transports.Console()]
});

function handleRequest() {
  const span = tracer.startSpan('handle_request');
  context.with(trace.setSpan(context.active(), span), () => {
    // Logs automatically include trace context
    logger.info('Processing started', { user_id: '12345' });
    // Do work...
    logger.info('Processing completed');
    span.end();
  });
}

// logback.xml configuration:
// <pattern>%d{HH:mm:ss.SSS} trace_id=%X{trace_id} span_id=%X{span_id} - %msg%n</pattern>

import io.opentelemetry.api.trace.Span;
import io.opentelemetry.context.Context;
import org.slf4j.MDC;

// Use OpenTelemetry Java agent for automatic MDC injection
// Or manually inject:
Span span = Span.current();
SpanContext spanContext = span.getSpanContext();

MDC.put("trace_id", spanContext.getTraceId());
MDC.put("span_id", spanContext.getSpanId());

logger.info("Processing request");

MDC.clear();

func logWithContext(ctx context.Context, msg string) {
    span := trace.SpanFromContext(ctx)
    if span.SpanContext().IsValid() {
        spanCtx := span.SpanContext()
        log.Printf("%s trace_id=%s span_id=%s",
            msg,
            spanCtx.TraceID().String(),
            spanCtx.SpanID().String(),
        )
    } else {
        log.Printf("%s", msg)
    }
}

from opentelemetry import trace
import logging

def log_with_context(msg):
    span = trace.get_current_span()
    span_ctx = span.get_span_context()
    if span_ctx.is_valid:
        logging.info(
            f"{msg} trace_id={format(span_ctx.trace_id, '032x')} "
            f"span_id={format(span_ctx.span_id, '016x')}"
        )
    else:
        logging.info(msg)

const { trace } = require('@opentelemetry/api');

function logWithContext(msg) {
  const span = trace.getActiveSpan();
  if (span) {
    const spanCtx = span.spanContext();
    console.log(
      `${msg} trace_id=${spanCtx.traceId} span_id=${spanCtx.spanId}`
    );
  } else {
    console.log(msg);
  }
}

import (
    "go.opentelemetry.io/otel/log"
    "go.opentelemetry.io/otel/log/global"
)

// Get logger
logger := global.LoggerProvider().Logger("my-service")

func handleRequest(ctx context.Context) {
    // Emit log record
    logger.Emit(ctx, log.Record{
        Severity:  log.SeverityInfo,
        Body:      log.StringValue("Request processed successfully"),
        Attributes: []log.KeyValue{
            log.String("user.id", "12345"),
            log.String("http.method", "GET"),
            log.Int("http.status_code", 200),
            log.Int64("duration_ms", 245),
        },
    })
}

// Error logging
func handleError(ctx context.Context, err error) {
    logger.Emit(ctx, log.Record{
        Severity: log.SeverityError,
        Body:     log.StringValue("Request failed"),
        Attributes: []log.KeyValue{
            log.String("error.type", "DatabaseError"),
            log.String("error.message", err.Error()),
        },
    })
}

from opentelemetry._logs import get_logger_provider
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor

# Set up logger provider
logger_provider = LoggerProvider()
get_logger_provider().add_log_record_processor(
    BatchLogRecordProcessor(exporter)
)

# Get logger
logger = logger_provider.get_logger("my-service")

# Emit log
logger.emit(
    body="Request processed successfully",
    severity_number=9,  # INFO
    attributes={
        "user.id": "12345",
        "http.method": "GET",
        "http.status_code": 200,
        "duration_ms": 245
    }
)

const { logs } = require('@opentelemetry/api-logs');

const logger = logs.getLogger('my-service');

function handleRequest() {
  logger.emit({
    severityNumber: 9, // INFO
    body: 'Request processed successfully',
    attributes: {
      'user.id': '12345',
      'http.method': 'GET',
      'http.status_code': 200,
      'duration_ms': 245
    }
  });
}

// ❌ Bad: Logging sensitive data
logger.Info("User login",
    zap.String("email", email),
    zap.String("password", password),  // Never log passwords!
)

// ✅ Good: Redact sensitive fields
logger.Info("User login",
    zap.String("email", maskEmail(email)),  // user@example.com → u***@example.com
    zap.String("user.id", userID),
)

func maskEmail(email string) string {
    parts := strings.Split(email, "@")
    if len(parts) != 2 {
        return "***"
    }
    return string(parts[0][0]) + "***@" + parts[1]
}

# ❌ Bad: Logging sensitive data
logger.info("User login", extra={
    "email": email,
    "password": password  # Never log passwords!
})

# ✅ Good: Redact sensitive fields
logger.info("User login", extra={
    "email": mask_email(email),  # user@example.com → u***@example.com
    "user_id": user_id
})

def mask_email(email):
    parts = email.split("@")
    if len(parts) != 2:
        return "***"
    return parts[0][0] + "***@" + parts[1]

// ❌ Bad: Logging sensitive data
logger.info('User login', {
  email: email,
  password: password  // Never log passwords!
});

// ✅ Good: Redact sensitive fields
logger.info('User login', {
  email: maskEmail(email),  // user@example.com → u***@example.com
  user_id: userId
});

function maskEmail(email) {
  const parts = email.split('@');
  if (parts.length !== 2) {
    return '***';
  }
  return parts[0][0] + '***@' + parts[1];
}

// ❌ Bad: Expensive operation always runs
logger.Debug("User data: " + expensiveJSONMarshal(user))

// ✅ Good: Check level first
if logger.Level() <= zap.DebugLevel {
    logger.Debug("User data", zap.String("user_json", expensiveJSONMarshal(user)))
}

# ❌ Bad: Expensive operation always runs
logger.debug(f"User data: {expensive_json_marshal(user)}")

# ✅ Good: Check level first
if logger.isEnabledFor(logging.DEBUG):
    logger.debug("User data", extra={"user_json": expensive_json_marshal(user)})

// ❌ Bad: Expensive operation always runs
logger.debug(`User data: ${expensiveJSONMarshal(user)}`);

// ✅ Good: Check level first
if (logger.isDebugEnabled()) {
  logger.debug('User data', { user_json: expensiveJSONMarshal(user) });
}

var logCounter int64

func handleRequest() {
    count := atomic.AddInt64(&logCounter, 1)

    // Only log every 100th request
    if count % 100 == 0 {
        logger.Info("Sampled request log", zap.Int64("request_count", count))
    }
}

import threading

log_counter = 0
counter_lock = threading.Lock()

def handle_request():
    global log_counter
    with counter_lock:
        log_counter += 1
        count = log_counter

    # Only log every 100th request
    if count % 100 == 0:
        logger.info("Sampled request log", extra={"request_count": count})

let logCounter = 0;

function handleRequest() {
  logCounter++;

  // Only log every 100th request
  if (logCounter % 100 === 0) {
    logger.info('Sampled request log', { request_count: logCounter });
  }
}

// Configure batch processor
processor := log.NewBatchProcessor(
    exporter,
    log.WithMaxQueueSize(2048),
    log.WithExportTimeout(30*time.Second),
    log.WithBatchSize(512),
)

from opentelemetry.sdk._logs.export import BatchLogRecordProcessor

# Configure batch processor
processor = BatchLogRecordProcessor(
    exporter,
    max_queue_size=2048,
    export_timeout_millis=30000,
    max_export_batch_size=512
)

const { BatchLogRecordProcessor } = require('@opentelemetry/sdk-logs');

// Configure batch processor
const processor = new BatchLogRecordProcessor(exporter, {
  maxQueueSize: 2048,
  exportTimeoutMillis: 30000,
  maxExportBatchSize: 512
});

// Ensure you're passing context to logger
logger.Ctx(ctx).Info("message")  // ✅ Correct
logger.Info("message")             // ❌ No context

# Ensure logging handler is configured
from opentelemetry.sdk._logs import LoggingHandler
logging.getLogger().addHandler(LoggingHandler())

// Measure logging overhead
start := time.Now()
logger.Info("test message", zap.String("key", "value"))
fmt.Printf("Log operation took: %v\n", time.Since(start))

import time

# Measure logging overhead
start = time.time()
logger.info("test message", extra={"key": "value"})
print(f"Log operation took: {time.time() - start:.6f}s")

// Measure logging overhead
const start = Date.now();
logger.info('test message', { key: 'value' });
console.log(`Log operation took: ${Date.now() - start}ms`);

processor := log.NewBatchProcessor(exporter)  // Async batching
// vs
processor := log.NewSimpleProcessor(exporter)  // Synchronous

from opentelemetry.sdk._logs.export import BatchLogRecordProcessor, SimpleLogRecordProcessor

processor = BatchLogRecordProcessor(exporter)  # Async batching
# vs
processor = SimpleLogRecordProcessor(exporter)  # Synchronous

const { BatchLogRecordProcessor, SimpleLogRecordProcessor } = require('@opentelemetry/sdk-logs');

const processor = new BatchLogRecordProcessor(exporter);  // Async batching
// vs
const processor = new SimpleLogRecordProcessor(exporter);  // Synchronous

// Only ERROR and above in production
if env == "production" {
    logger = logger.WithLevel(zap.ErrorLevel)
}

import logging

# Only ERROR and above in production
if env == "production":
    logger.setLevel(logging.ERROR)

// Only ERROR and above in production
if (env === 'production') {
  logger.level = 'error';
}

// ❌ Too many attributes
logger.Info("msg", zap.String("a", "1"), zap.String("b", "2"), ..., zap.String("z", "26"))

// ✅ Only essential attributes
logger.Info("msg", zap.String("error.type", "timeout"), zap.Int("duration_ms", 5000))

# ❌ Too many attributes
logger.info("msg", extra={"a": "1", "b": "2", ..., "z": "26"})

# ✅ Only essential attributes
logger.info("msg", extra={"error.type": "timeout", "duration_ms": 5000})

// ❌ Too many attributes
logger.info('msg', { a: '1', b: '2', ..., z: '26' });

// ✅ Only essential attributes
logger.info('msg', { 'error.type': 'timeout', duration_ms: 5000 });

// Sample verbose logs
if level == DEBUG && rand.Float64() > 0.01 {  // Keep 1%
    return
}

import random

# Sample verbose logs
if level == logging.DEBUG and random.random() > 0.01:  # Keep 1%
    return

// Sample verbose logs
if (level === 'debug' && Math.random() > 0.01) {  // Keep 1%
  return;
}