Demo Using Python Stdlib

In this lesson we compare two approaches to emitting logs with OpenTelemetry in Python:

Verbose: manually creating and emitting LogRecord objects via an OpenTelemetry logger.
Concise: using the Python standard library logging module and forwarding those records into OpenTelemetry.

We first show the verbose approach (explicit, but repetitive), then the standard-library approach (concise), and finally how to wire the stdlib logger into OpenTelemetry so your existing logging.info(...) calls produce OpenTelemetry log records automatically.

At-a-glance comparison

Approach	Pros	Cons	When to use
Manual `LogRecord` (OpenTelemetry SDK)	Full control over every field; explicit structure	Verbose — must set timestamp, severity, attributes manually	Low-level integrations, custom pre-processing
Python `logging` + forwarder	Concise and familiar API; auto-populates severity, timestamps, code attributes	Slight indirection; requires handler configuration	Most apps — minimal changes to existing codebases

1) Verbose: emitting OpenTelemetry `LogRecord` directly

This approach constructs LogRecord objects and emits them through an OpenTelemetry Logger. It’s explicit, but repetitive: every log must include timestamp, severity, body, and other fields.

import time
import logging
from opentelemetry.sdk._logs import LoggerProvider, LogRecord
from opentelemetry._logs import set_logger_provider, get_logger
from opentelemetry.sdk._logs.export import ConsoleLogExporter, BatchLogRecordProcessor
from opentelemetry._logs.severity import SeverityNumber

# OpenTelemetry setup
logger_provider = LoggerProvider()
exporter = ConsoleLogExporter()
processor = BatchLogRecordProcessor(exporter=exporter)
logger_provider.add_log_record_processor(processor)
set_logger_provider(logger_provider=logger_provider)

logger = get_logger("flight-booking", "0.1.2")

def book_flight():
    # Verbose: construct and emit a LogRecord manually
    logger.emit(
        LogRecord(
            body="Starting the booking flight process",
            timestamp=time.time_ns(),
            severity_text="INFO",
            severity_number=SeverityNumber.INFO,
        )
    )
    search_flights()
    reserve_flight()

def search_flights():
    pass

def reserve_flight():
    pass

This is useful when you need precise control over the OpenTelemetry LogRecord payload, but it quickly becomes cumbersome for everyday application logging.

2) Simpler: Python standard library `logging`

The Python standard logging module is concise and widely used. By default it writes human-readable text to the console (or to files/handlers you configure), but those records are not OpenTelemetry LogRecords until you forward them.

import logging

# Configure the stdlib logger to accept all levels
logging.basicConfig(level=logging.NOTSET)

def book_flight():
    logging.info("starting booking process")
    search_flights()
    reserve_flight()

def search_flights():
    logging.info("Searching for flights")

def reserve_flight():
    logging.warning("Reserving flight")

Running the script produces the typical stdlib output:

Documents/courses/logs-demo via 🐍 v3.11.13 (.venv) on ☁ (us-east-1)
> python main.py
INFO:root:starting booking process

This is concise and convenient for everyday development, but those messages are not structured OpenTelemetry logs unless forwarded.

3) Forward stdlib `logging` to OpenTelemetry

You can wire the Python stdlib logger into OpenTelemetry using a LoggingHandler provided by the OpenTelemetry SDK. The handler converts logging.LogRecord instances into OpenTelemetry LogRecords and forwards them to the configured LoggerProvider. With this in place, existing logging.info(...) calls generate structured OpenTelemetry logs automatically. Example: forward stdlib logs to OpenTelemetry and export to the console as JSON.

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

# OpenTelemetry provider and exporter setup
logger_provider = LoggerProvider()
exporter = ConsoleLogExporter()
processor = BatchLogRecordProcessor(exporter=exporter)
logger_provider.add_log_record_processor(processor)
set_logger_provider(logger_provider=logger_provider)

# Create a LoggingHandler that forwards stdlib logs to OpenTelemetry
handler = LoggingHandler(level=logging.NOTSET, logger_provider=logger_provider)

# Configure stdlib logging to use that handler
logging.basicConfig(handlers=[handler], level=logging.NOTSET)

# Use the standard library logger throughout your app
def book_flight():
    logging.info("starting booking process")
    search_flights()
    reserve_flight()

def search_flights():
    logging.info("Searching for flights")

def reserve_flight():
    logging.warning("Reserving flight")

Notes:

If you still want the original stdlib text output on the console in addition to OpenTelemetry JSON output, attach a standard logging.StreamHandler() alongside the LoggingHandler.
The LoggingHandler will populate fields such as severity text/number, timestamps, and code attributes (file path, function name, line number) automatically.

Exporter output (ConsoleLogExporter) — formatted for readability:

{
    "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": 25
    },
    "dropped_attributes": 0,
    "timestamp": "2025-09-18T23:22:33.738287Z",
    "observed_timestamp": "2025-09-18T23:22:33.738303Z",
    "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": ""
}

Forwarding the Python stdlib logger to OpenTelemetry lets existing codebases emit structured OpenTelemetry logs with minimal changes — configure the handler once and continue using logging everywhere.

Links and references

OpenTelemetry: https://opentelemetry.io/
Python logging documentation: https://docs.python.org/3/library/logging.html
OpenTelemetry Python SDK: https://github.com/open-telemetry/opentelemetry-python

If you want a quick checklist for adopting stdlib-forwarding:

Step	Action
1	Install OpenTelemetry Python SDK and exporter packages.
2	Create and configure a `LoggerProvider` and exporter (e.g., `ConsoleLogExporter`).
3	Create `LoggingHandler` with the `logger_provider` and attach it to `logging`.
4	Optionally attach `StreamHandler` if you also want human-readable console logs.
5	Run your app — `logging` calls will now produce OpenTelemetry `LogRecord`s.

This setup gives you the familiarity of the Python logging API with the structured, observable benefits of OpenTelemetry logging.

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 Using Python Stdlib

At-a-glance comparison

1) Verbose: emitting OpenTelemetry `LogRecord` directly

2) Simpler: Python standard library `logging`

3) Forward stdlib `logging` to OpenTelemetry

Links and references

Watch Video

​At-a-glance comparison

​1) Verbose: emitting OpenTelemetry LogRecord directly

​2) Simpler: Python standard library logging

​3) Forward stdlib logging to OpenTelemetry

​Links and references

Watch Video

At-a-glance comparison

1) Verbose: emitting OpenTelemetry `LogRecord` directly

2) Simpler: Python standard library `logging`

3) Forward stdlib `logging` to OpenTelemetry

Links and references