Skip to content

OpenTelemetry Log Export Not Working Fix

DodaTech Updated 2026-06-24 3 min read

In this tutorial, you'll learn about OpenTelemetry Log Export Not Working Fix. We cover key concepts, practical examples, and best practices.

Your OpenTelemetry logs are not exported — the log records are created but never appear in Loki or your logging backend. The log SDK is not initialized, the log record processor is missing, or the OTLP log exporter is not configured.

The Problem

import logging
from opentelemetry._logs import set_logger_provider

# WRONG: no log processor configured
logger = logging.getLogger(__name__)
logger.warning("Something happened")

The log record is created in the standard Python logging system but never exported via OpenTelemetry because the log handler and exporter are not configured.

Step-by-Step Fix

1. Configure the OpenTelemetry log SDK

import logging
from opentelemetry._logs import set_logger_provider
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter

exporter = OTLPLogExporter(insecure=True)
logger_provider = LoggerProvider(
    resource=Resource.create({"service.name": "myapp"})
)
logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
set_logger_provider(logger_provider)

2. Use the OpenTelemetry logging API

from opentelemetry._logs import set_logger_provider
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor, ConsoleLogExporter
from opentelemetry.sdk.resources import Resource

logger_provider = LoggerProvider(
    resource=Resource.create({"service.name": "myapp"})
)
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(ConsoleLogExporter())
)
set_logger_provider(logger_provider)

from opentelemetry._logs import get_logger

logger = get_logger(__name__)

def handle_request(request_id):
    logger.warning("Request latency high", extra={
        "request.id": request_id,
        "latency_ms": 2500,
    })

3. Bridge standard logging to OpenTelemetry

import logging
from opentelemetry._logs import set_logger_provider
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
from opentelemetry.instrumentation.logging import LoggingInstrumentor

LoggingInstrumentor().instrument()

exporter = OTLPLogExporter(insecure=True)
logger_provider = LoggerProvider()
logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
set_logger_provider(logger_provider)

# Now standard logging calls are exported via OTLP
logging.warning("Standard log message with trace context")

4. Export logs to Loki

# otel-collector-config.yaml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317

exporters:
  loki:
    endpoint: http://loki:3100/loki/api/v1/push
    labels:
      resource:
        service.name: "service"
        service.namespace: "namespace"
      attributes:
        level: "severity"

service:
  pipelines:
    logs:
      receivers: [otlp]
      exporters: [loki]

5. Add trace context correlation

from opentelemetry import trace
from opentelemetry._logs import get_logger

tracer = trace.get_tracer(__name__)
logger = get_logger(__name__)

def process():
    with tracer.start_as_current_span("process") as span:
        logger.warning("Processing started")
        # Logs automatically include trace_id and span_id

Expected output in Loki:

{"timestamp": "2026-06-24T10:00:00Z", "severity": "WARNING",
 "body": "Processing started",
 "trace_id": "1234abcd5678efgh",
 "span_id": "5678efgh1234abcd"}

Prevention Tips

  • Initialize the log SDK before creating any loggers
  • Use BatchLogRecordProcessor with OTLP exporter for production
  • Bridge standard logging frameworks with auto-instrumentation
  • Configure log pipelines in the OpenTelemetry Collector
  • Verify log export with console exporter first

Common Mistakes with log export

  1. Forgetting deriving (Show, Eq) on custom data types needed for debugging
  2. Placing the wildcard pattern first in case expressions, making all subsequent patterns unreachable
  3. Using head and tail instead of pattern matching, causing runtime errors on empty lists

These mistakes appear frequently in real-world OPENTELEMETRY code. DodaTech's contributors have identified these patterns through analysis of open-source projects and production systems.

Practice Exercise

Write a pure function that safely divides two integers using Maybe, then test it with edge cases like division by zero and negative numbers.

This exercise reinforces the concepts covered in this guide. Try implementing it before checking online solutions.

FAQ

### How do OpenTelemetry logs differ from tracing?

Logs are discrete records with a timestamp and message. Traces represent operations with start/end times and causal relationships. OpenTelemetry correlates logs with traces via trace_id and span_id attributes, enabling unified observability.

Can I send existing log files to OpenTelemetry?

Yes, use the filelog receiver in the OpenTelemetry Collector: receivers: filelog: { include: [/var/log/*.log] }. The collector parses log files and forwards them to configured exporters. This works with any log format.

Does OpenTelemetry replace my existing logging framework?

No, OpenTelemetry complements existing logging. Use the logging instrumentation package to bridge frameworks (Python logging, Log4j, Serilog) to OpenTelemetry. Your existing log statements continue working with enhanced context.

Built by the developers of DodaTech

Doda Browser, DodaZIP & Durga Antivirus Pro