Demo Zero Code Techniques in Python

This article demonstrates zero-code (auto) instrumentation for Python applications using OpenTelemetry. We’ll:

Start with a minimal Flask app that has no OpenTelemetry packages.
Install the OpenTelemetry distro and OTLP exporter.
Use the auto-instrumentation tooling to capture traces and metrics without modifying application code.
Show a slightly more complex example that exercises HTTP and database instrumentation.

Relevant links:

OpenTelemetry: https://opentelemetry.io/
Flask: https://palletsprojects.com/p/flask/
OTLP spec: https://opentelemetry.io/docs/reference/specification/protocol/otlp/

1. Minimal Flask app (products.py)

This tiny Flask application is the whole codebase used for the initial demo.

# products.py
from flask import Flask

app = Flask(__name__)

@app.route("/")
def charge():
    return "Here are all of the available products"

if __name__ == "__main__":
    app.run(debug=False, use_reloader=False)

Run it locally:

python products.py

Quick verification with curl:

curl 127.0.0.1:5000/
# Output:
Here are all of the available products

At this point there are no OpenTelemetry packages installed. Example pip freeze output (showing common packages but no OpenTelemetry):

pip freeze
# Example output:
blinker==1.9.0
certifi==2025.8.3
charset-normalizer==3.4.3
click==8.2.1
Flask==3.1.2
idna==3.10
itsdangerous==2.2.0
Jinja2==3.1.6
MarkupSafe==3.0.2
psycopg2-binary==2.9.10
requests==2.32.5
urllib3==2.5.0
Werkzeug==3.1.3

Because this repository contains only products.py and no OpenTelemetry imports, it’s a perfect candidate to demonstrate zero-code (auto) instrumentation: we will add observability without changing application source.

2. Install OpenTelemetry distro and bootstrap instrumentation

Install the OpenTelemetry distro and the OTLP exporter, then let the bootstrapper add matching instrumentation libraries for installed packages:

pip install opentelemetry-distro opentelemetry-exporter-otlp
opentelemetry-bootstrap -a install

What the bootstrap command does:

Scans installed packages in the environment (e.g., Flask, requests, psycopg).
Installs opentelemetry-instrumentation-* packages that correspond to detected libraries (for example opentelemetry-instrumentation-flask, opentelemetry-instrumentation-requests, opentelemetry-instrumentation-psycopg2).

You should see output naming the installed instrumentation packages:

Successfully installed opentelemetry-instrumentation-flask-0.57b0 opentelemetry-instrumentation-urllib3-0.57b0

3. Run the app with the OpenTelemetry auto-instrumentation tool

There are two equivalent ways to configure auto-instrumentation:

Pass configuration as CLI flags to opentelemetry-instrument.
Set OTEL_ environment variables and run opentelemetry-instrument without flags.

Compare the two approaches:

Configuration method	Example usage	Notes
CLI flags	`opentelemetry-instrument --traces_exporter console,otlp --metrics_exporter console --service_name products-service --exporter_otlp_endpoint http://localhost:4318 python products.py`	Flags can be convenient for one-off runs.
Environment variables	`export OTEL_SERVICE_NAME=products-service` `export OTEL_TRACES_EXPORTER=console,otlp` `export OTEL_METRICS_EXPORTER=console` `export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4318/v1/traces` `opentelemetry-instrument python products.py`	Use env vars for reproducible deployments or containerized apps. See note about OTLP HTTP endpoint below.

When configuring OTLP over HTTP via environment variables, include the full path .../v1/traces (for traces). The CLI flag --exporter_otlp_endpoint may accept a host-only value and append the proper path automatically, but the environment variable OTEL_EXPORTER_OTLP_TRACES_ENDPOINT typically must include the full http://<host>:<port>/v1/traces URL.

Example: instrumenting and generating a trace (products)

Start the instrumented app using CLI flags (console exporter prints spans to stdout and OTLP forwards to the configured endpoint):

opentelemetry-instrument \
  --traces_exporter console,otlp \
  --metrics_exporter console \
  --service_name products-service \
  --exporter_otlp_endpoint http://localhost:4318 \
  python products.py

Generate a request:

curl 127.0.0.1:5000/
# Response:
Here are all of the available products

The console exporter will emit JSON representations of spans. Representative (shortened) span output:

{
  "name": "GET /",
  "context": {
    "trace_id": "0x2be0962ba5391c2e8255ba691123dd02",
    "span_id": "0x6315774311f175e3",
    "trace_state": ""
  },
  "kind": "SpanKind.SERVER",
  "parent_id": null,
  "start_time": "2025-09-10T01:05:15.588182Z",
  "end_time": "2025-09-10T01:05:15.589007Z",
  "status": { "status_code": "UNSET" },
  "attributes": {
    "http.method": "GET",
    "http.server_name": "127.0.0.1",
    "http.scheme": "http",
    "http.host": "127.0.0.1:5000",
    "http.target": "/",
    "net.peer.ip": "127.0.0.1",
    "http.user_agent": "curl/8.7.1",
    "http.flavor": "1.1",
    "http.route": "/",
    "http.status_code": 200
  },
  "resource": {
    "attributes": { "telemetry.sdk.language": "python" }
  }
}

This trace shows the route, trace ID, span ID, span kind, start/end times and several automatically-added attributes provided by the Flask instrumentation package. If you export to a backend such as Jaeger (via an OpenTelemetry Collector or an OTLP receiver forwarding to Jaeger), you can view traces in the Jaeger UI:

The image shows a Jaeger trace UI displaying a trace for the "products-service" with a GET request, including details like HTTP method, status code, and various tags related to the operation.

All telemetry above was produced automatically by the Flask instrumentation package that opentelemetry-bootstrap -a install added—no changes to products.py were required.

4. Configure with environment variables (example)

A concise env-var example:

export OTEL_SERVICE_NAME=products-service
export OTEL_TRACES_EXPORTER=console,otlp
export OTEL_METRICS_EXPORTER=console
# Include /v1/traces when using env var for OTLP HTTP traces endpoint:
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4318/v1/traces

opentelemetry-instrument python products.py

Verify environment variables:

printenv | grep -i OTEL
# Example:
OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
OTEL_SERVICE_NAME=products-service
OTEL_TRACES_EXPORTER=console,otlp
OTEL_METRICS_EXPORTER=console
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:4318/v1/traces

If OTEL_EXPORTER_OTLP_TRACES_ENDPOINT omits /v1/traces, you may observe export failures such as “failed to export span batch” or HTTP 404/400 responses from the OTLP HTTP receiver. Including /v1/traces typically resolves that issue.

5. Demonstration: a slightly more complex app (crypto.py)

Next, we instrument a slightly richer example that uses Flask, requests, and psycopg2. Because instrumentation packages for these libraries are available and were installed by the bootstrap step, the application is auto-instrumented without source changes. Representative excerpts from crypto.py:

# crypto.py (excerpts)
from flask import Flask
import requests
import psycopg2
import pprint
from datetime import datetime

DB_CONFIG = {
    "dbname": "crypto",
    "user": "postgres",
    "password": "postgres",
    "host": "localhost",
    "port": 5432,
}

CMC_API_KEY = "YOUR_COINMARKETCAP_API_KEY"
CMC_URL = "https://pro-api.coinmarketcap.com/v2/cryptocurrency/quotes/latest"

Flask route:

app = Flask(__name__)

@app.route("/price")
def charge():
    price = fetch_bitcoin_price()
    store_price_in_db(price)
    return {"data": price}

if __name__ == "__main__":
    app.run(debug=False, use_reloader=False)

Fetch current Bitcoin price (HTTP call via requests):

def fetch_bitcoin_price():
    url = CMC_URL
    params = {"symbol": "BTC"}
    headers = {
        "Accepts": "application/json",
        "X-CMC_PRO_API_KEY": CMC_API_KEY,
    }
    response = requests.get(url, params=params, headers=headers)
    response.raise_for_status()

    data = response.json()
    btc_data = data["data"]["BTC"]
    if not btc_data:
        raise ValueError("No BTC data found")
    # Extract numeric price in USD from returned structure (example key)
    price = btc_data["quote"]["USD"]["price"]
    return price

Store the price in PostgreSQL (psycopg2):

def store_price_in_db(price):
    conn = psycopg2.connect(**DB_CONFIG)
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS bitcoin_prices (
            id SERIAL PRIMARY KEY,
            price_usd NUMERIC,
            fetched_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        );
    """)
    cursor.execute(
        "INSERT INTO bitcoin_prices (price_usd, fetched_at) VALUES (%s, %s)",
        (price, datetime.utcnow())
    )
    conn.commit()
    cursor.close()
    conn.close()
    print(f"Stored Bitcoin price ${price} in database.")

Because Flask, requests, and psycopg2 were instrumented by the bootstrap step, running this application with opentelemetry-instrument captures multiple spans in a single trace:

Incoming Flask server span (HTTP server).
Outgoing HTTP client span (requests → CoinMarketCap).
Database spans for SQL statements (psycopg2) with db.* semantic attributes.

Run the instrumented crypto app:

opentelemetry-instrument \
  --traces_exporter console,otlp \
  --metrics_exporter console \
  --service_name crypto-service \
  --exporter_otlp_endpoint http://localhost:4318 \
  python crypto.py

Trigger the endpoint:

curl 127.0.0.1:5000/price
# Example JSON response:
{"data": 111084.935888223}

Inspect the trace in Jaeger or another OTLP-compatible backend to see the Flask server span, the outgoing HTTP span to pro-api.coinmarketcap.com, and DB spans showing executed SQL statements.

The image shows a Jaeger UI displaying trace timelines for a "crypto-service" GET request to "/price," with details on service operations and execution times.

Examples of DB statements that appear as spans (captured automatically):

CREATE TABLE IF NOT EXISTS bitcoin_prices (
    id SERIAL PRIMARY KEY,
    price_usd NUMERIC,
    fetched_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO bitcoin_prices (price_usd, fetched_at) VALUES (%s, %s)

All telemetry was produced automatically by the instrumentation libraries that were added by opentelemetry-bootstrap -a install—no code changes to crypto.py were required.

Summary & best practices

Auto-instrumentation enables zero-code observability for supported libraries (Flask, requests, psycopg2, etc.).
Install opentelemetry-distro and opentelemetry-exporter-otlp, then run:
- opentelemetry-bootstrap -a install to add matching opentelemetry-instrumentation-* packages.
Run your application with opentelemetry-instrument using CLI flags or OTEL_ environment variables.
When using environment variables for OTLP HTTP traces endpoint, include /v1/traces in OTEL_EXPORTER_OTLP_TRACES_ENDPOINT.
Exported telemetry can be sent to console for debugging or to OTLP-compatible backends (via OpenTelemetry Collector) such as Jaeger.

Links and references

OpenTelemetry: https://opentelemetry.io/
OpenTelemetry Python distro (PyPI): https://pypi.org/project/opentelemetry-distro/
OpenTelemetry OTLP exporter (PyPI): https://pypi.org/project/opentelemetry-exporter-otlp/
OpenTelemetry Collector: https://opentelemetry.io/docs/collector/
Jaeger: https://www.jaegertracing.io/
Flask: https://palletsprojects.com/p/flask/
requests: https://docs.python-requests.org/
psycopg2: https://www.psycopg.org/

Demo Zero Code Techniques in Python

1. Minimal Flask app (products.py)

2. Install OpenTelemetry distro and bootstrap instrumentation

3. Run the app with the OpenTelemetry auto-instrumentation tool

Example: instrumenting and generating a trace (products)

4. Configure with environment variables (example)

5. Demonstration: a slightly more complex app (crypto.py)

Summary & best practices

Links and references

Watch Video

Practice Lab

​1. Minimal Flask app (products.py)

​2. Install OpenTelemetry distro and bootstrap instrumentation

​3. Run the app with the OpenTelemetry auto-instrumentation tool

​Example: instrumenting and generating a trace (products)

​4. Configure with environment variables (example)

​5. Demonstration: a slightly more complex app (crypto.py)

​Summary & best practices

​Links and references

Watch Video

Practice Lab

1. Minimal Flask app (products.py)

2. Install OpenTelemetry distro and bootstrap instrumentation

3. Run the app with the OpenTelemetry auto-instrumentation tool

Example: instrumenting and generating a trace (products)

4. Configure with environment variables (example)

5. Demonstration: a slightly more complex app (crypto.py)

Summary & best practices

Links and references