Demo Integrating Traces With Logs

Earlier we configured Python logging and wired the standard library logger to forward records to OpenTelemetry. That initial setup correctly emitted log records, but the records did not include any trace or span identifiers because tracing had not been configured. Below is the original logging setup used for the demo:

logger_provider.add_log_record_processor(processor)

set_logger_provider(logger_provider=logger_provider)

logger = get_logger("flight-booking", "0.1.2")
handler = LoggingHandler(level=logging.NOTSET, logger_provider=logger_provider)
logging.basicConfig(handlers=[handler], level=logging.NOTSET)

def book_flight():
    # Previously we emitted a LogRecord directly:
    # logger.emit(LogRecord(body="Starting the booking flight process",
    #                       timestamp=time.time_ns(), severity_text="INFO",
    #                       severity_number=SeverityNumber.INFO))
    logging.info("starting booking process")
    search_flights()

Why trace IDs were missing

OpenTelemetry can automatically attach trace_id and span_id to log records, but only when a tracer is configured and a span is active.
With no tracer, logs still include other metadata (file, function, line) but will show zeroed or empty trace/span identifiers.

Example log record produced before tracing was configured (note the zeroed trace_id and span_id):

{
  "body": "WARNING:root:Reserving flight",
  "severity_number": 13,
  "severity_text": "WARN",
  "attributes": {
    "code.file.path": "/Users/sanjeev/Documents/courses/logs-demo/main.py",
    "code.function.name": "reserve_flight",
    "code.line.number": 37
  },
  "dropped_attributes": 0,
  "timestamp": "2025-09-18T23:23:48.279612Z",
  "observed_timestamp": "2025-09-18T23:23:48.279616Z",
  "trace_id": "0x00000000000000000000000000000000",
  "span_id": "0x0000000000000000",
  "trace_flags": 0,
  "resource": {
    "attributes": {
      "telemetry.sdk.language": "python",
      "telemetry.sdk.name": "opentelemetry",
      "telemetry.sdk.version": "1.37.0",
      "service.name": "unknown_service"
    },
    "schema_url": ""
  },
  "event_name": ""
}

Complete corrected setup To automatically correlate logs with traces, install and configure both a logging provider and a tracing provider. First import the required OpenTelemetry modules:

import logging
import time

from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry._logs import set_logger_provider, get_logger
from opentelemetry.sdk._logs.export import ConsoleLogExporter, BatchLogRecordProcessor
from opentelemetry._logs.severity import SeverityNumber

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor

Next configure the logging pipeline and a simple tracing pipeline that export to the console. This ensures spans and log records are printed and that logs created while a span is active will include the span and trace identifiers.

# --- Logging setup ---
logger_provider = LoggerProvider()
log_exporter = ConsoleLogExporter()
log_processor = BatchLogRecordProcessor(log_exporter)
logger_provider.add_log_record_processor(log_processor)
set_logger_provider(logger_provider=logger_provider)

handler = LoggingHandler(level=logging.NOTSET, logger_provider=logger_provider)
logging.basicConfig(handlers=[handler], level=logging.NOTSET)
logger = get_logger("flight-booking", "0.1.2")

# --- Tracing setup ---
tracer_provider = TracerProvider()
span_exporter = ConsoleSpanExporter()
span_processor = SimpleSpanProcessor(span_exporter)
tracer_provider.add_span_processor(span_processor)
trace.set_tracer_provider(tracer_provider)
tracer = trace.get_tracer(__name__)

Note: with the tracer in place, any log records emitted while a span is active will include that span’s trace_id and span_id automatically.

The tracer.start_as_current_span method can be used either as a context manager or as a decorator. When used as a decorator, the decorated function runs with the new span as the current active span for the duration of the function.

Wrap logical operations with spans Update your functions so each logical operation runs inside a span. When logging occurs inside those spans, the log records will have the associated trace_id and span_id, enabling automatic correlation between logs and traces.

@tracer.start_as_current_span("Book Flight")
def book_flight():
    logging.info("starting booking process")
    search_flights()
    reserve_flight()


@tracer.start_as_current_span("Search Flight")
def search_flights():
    logging.info("Searching for flights")


@tracer.start_as_current_span("Reserve Flight")
def reserve_flight():
    logging.warning("Reserving flight")

What you will see on the console

Spans printed by the ConsoleSpanExporter include trace_id and span_id.
Log records printed by the ConsoleLogExporter include the same trace_id and span_id when generated while the span is active.

Example span output (representative/truncated):

{
  "name": "Book Flight",
  "context": {
    "trace_id": "0x753bf54e586511c2888937f1d468f2be",
    "span_id": "0xc591f89f61e3b890",
    "trace_state": "[]"
  },
  "kind": "SpanKind.INTERNAL",
  "parent_id": null,
  "start_time": "2025-09-18T23:28:20.545641Z",
  "end_time": "2025-09-18T23:28:20.546201Z",
  "status": { "status_code": "UNSET" },
  "attributes": {},
  "events": [],
  "links": [],
  "resource": {
    "attributes": {
      "telemetry.sdk.language": "python",
      "telemetry.sdk.name": "opentelemetry",
      "telemetry.sdk.version": "1.37.0",
      "service.name": "unknown_service"
    },
    "schema_url": ""
  }
}

Corresponding log record for the “Book Flight” operation (now containing non-zero trace/span IDs):

{
  "body": "INFO:root:starting booking process",
  "severity_number": 9,
  "severity_text": "INFO",
  "attributes": {
    "code.file.path": "/Users/sanjeev/Documents/courses/logs-demo/main.py",
    "code.function.name": "book_flight",
    "code.line.number": 38
  },
  "timestamp": "2025-09-18T23:28:20.546122Z",
  "observed_timestamp": "2025-09-18T23:28:20.546130Z",
  "trace_id": "0x753bf54e586511c2888937f1d468f2be",
  "span_id": "0xc591f89f61e3b890",
  "trace_flags": 1,
  "resource": {
    "attributes": {
      "telemetry.sdk.language": "python",
      "telemetry.sdk.name": "opentelemetry",
      "telemetry.sdk.version": "1.37.0",
      "service.name": "unknown_service"
    },
    "schema_url": ""
  },
  "event_name": ""
}

“Reserve Flight” span and matching log record (same trace_id, unique span_id):

{
  "name": "Reserve Flight",
  "context": {
    "trace_id": "0x753bf54e586511c2888937f1d468f2be",
    "span_id": "0x76384adc45c2dc48",
    "trace_state": "[]"
  },
  "kind": "SpanKind.INTERNAL",
  "parent_id": "0xc591f89f61e3b89b",
  "start_time": "2025-09-18T23:28:20.546112Z",
  "end_time": "2025-09-18T23:28:20.546152Z",
  "status": { "status_code": "UNSET" },
  "attributes": {},
  "events": [],
  "links": [],
  "resource": {
    "attributes": {
      "telemetry.sdk.language": "python",
      "telemetry.sdk.name": "opentelemetry",
      "telemetry.sdk.version": "1.37.0",
      "service.name": "unknown_service"
    },
    "schema_url": ""
  }
}

{
  "body": "WARNING:root:Reserving flight",
  "severity_number": 13,
  "severity_text": "WARN",
  "attributes": {
    "code.file.path": "/Users/sanjeev/Documents/courses/logs-demo/main.py",
    "code.function.name": "reserve_flight",
    "code.line.number": 50
  },
  "timestamp": "2025-09-18T23:28:20.546122Z",
  "observed_timestamp": "2025-09-18T23:28:20.546130Z",
  "trace_id": "0x753bf54e586511c2888937f1d468f2be",
  "span_id": "0x76384adc45c2dc48",
  "trace_flags": 1,
  "resource": {
    "attributes": {
      "telemetry.sdk.language": "python",
      "telemetry.sdk.name": "opentelemetry",
      "telemetry.sdk.version": "1.37.0",
      "service.name": "unknown_service"
    },
    "schema_url": ""
  },
  "event_name": ""
}

Why this helps

Automatic log-trace correlation makes root-cause analysis much faster: you can jump from a log entry directly to the full trace to see timing, parent/child spans, and contextual attributes.
This approach requires minimal changes: set up a tracer and ensure operations run inside spans.

Run the script Add a standard entry point and run the program to see correlated spans and logs on the console:

if __name__ == "__main__":
    book_flight()

Summary table — components used

Component	Purpose	Example / Notes
`LoggerProvider`	Provides the logging SDK pipeline	Used with `BatchLogRecordProcessor` and `ConsoleLogExporter`
`LoggingHandler`	Bridges Python `logging` to OpenTelemetry	Attach to `logging.basicConfig` handlers
`TracerProvider`	Provides tracer instances and span processors	Add `SimpleSpanProcessor` + `ConsoleSpanExporter`
`tracer.start_as_current_span`	Creates an active span context	Can be used as decorator or context manager

Course Introduction

Observability Core Concepts

OpenTelemetry Core Concepts

Span Anatomy and Context Propagation

Instrumentation

Metrics Data Model

Recording Measurements

Logs

OTel Collector Foundations

OTel Collector Core Components

Transforming Telemetry – Pipeline Processing

OpenTelemetry in Kubernetes

OpenTelemetry Collector: Debugging, Operations, and Scaling

Extended Topics

Demo Integrating Traces With Logs

Watch Video