OTel For Python

13min
In this guide, we will walk you through the process of setting up and using OpenTelemetry in Python. You will learn how to instrument a simple application to emit traces, metrics, and logs.
Step 1: Prerequisites
Before diving into OpenTelemetry, make sure you have installed Python 3 on your local machine
Step 2: Example Application
For this tutorial, we will be using a basic Flask application. However, OpenTelemetry Python is compatible with other web frameworks like Django and FastAPI as well. Feel free to adapt the instructions to your preferred framework.
Step 3: Installation
Let’s set up the environment by creating a new directory and activating a virtual environment:
Text
mkdir otel-getting-started
cd otel-getting-started
python3 -m venv .
source ./bin/activate
mkdir otel-getting-started
cd otel-getting-started
python3 -m venv .
source ./bin/activate
﻿
2. Next, install Flask using pip:
Text
pip install flask
pip install flask
﻿
3. Create a file named app.py and add the following code to it:
Text
from random import randint
from flask import Flask

app = Flask(__name__)

@app.route(“/rolldice”)
def roll_dice():
 return str(do_roll())
def do_roll():
 return randint(1, 6)
from random import randint
from flask import Flask

app = Flask(__name__)

@app.route(“/rolldice”)
def roll_dice():
 return str(do_roll())
def do_roll():
 return randint(1, 6)
﻿
4. Run the application using the following command:
Text
flask run -p 8080
flask run -p 8080
﻿
Verify that the application is running by opening http://localhost:8080/rolldice in your web browser.
Step 4: Instrumentation
To automatically generate telemetry data, we will use the opentelemetry-instrument agent.
Start by installing the opentelemetry-distro package, which includes the OpenTelemetry API, SDK, and necessary tools:
Text
pip install opentelemetry-distro
pip install opentelemetry-distro
﻿
2. Next, run the opentelemetry-bootstrap command to install Flask instrumentation:
Text
opentelemetry-bootstrap -a install
opentelemetry-bootstrap -a install
﻿
Step 5: Run the Instrumented App
Now, you can run your instrumented app with opentelemetry-instrument and have the data printed to the console:
Text
opentelemetry-instrument \
 -- traces_exporter console \
 -- metrics_exporter console \
 -- logs_exporter console \
flask run -p 8080
opentelemetry-instrument \
 -- traces_exporter console \
 -- metrics_exporter console \
 -- logs_exporter console \
flask run -p 8080
﻿
Open http://localhost:8080/rolldice in your web browser and reload the page a few times. You should see the generated spans printed in the console, indicating the lifetime of a request to the /rolldice route.
Step 6: Add Manual Instrumentation to Automatic Instrumentation
While automatic instrumentation captures telemetry at the system edges, it doesn’t capture what’s happening within your application. To achieve that, you need to add manual instrumentation. Let’s link it with the automatic instrumentation we set up earlier.
Traces:
Modify app.pyto include code that initializes a tracer and creates a trace as a child of the automatically generated one:
Text
from opentelemetry import trace

from random import randint
from flask import Flask

tracer = trace.get_tracer(“diceroller.tracer”)

app = Flask(__name__)

@app.route(“/rolldice”)
def roll_dice():
 return str(do_roll())

def do_roll():
 with tracer.start_as_current_span(“do_roll”) as rollspan:
  res = randint(1, 6)
  rollspan.set_attribute(“roll.value”, res)
  return res
from opentelemetry import trace

from random import randint
from flask import Flask

tracer = trace.get_tracer(“diceroller.tracer”)

app = Flask(__name__)

@app.route(“/rolldice”)
def roll_dice():
 return str(do_roll())

def do_roll():
 with tracer.start_as_current_span(“do_roll”) as rollspan:
  res = randint(1, 6)
  rollspan.set_attribute(“roll.value”, res)
  return res
﻿
2. Run the app again:
Text
opentelemetry-instrument \
 -- traces_exporter console \
 -- metrics_exporter console \
flask run -p 8080
opentelemetry-instrument \
 -- traces_exporter console \
 -- metrics_exporter console \
flask run -p 8080
﻿
When you send a request to the server, you’ll see two spans in the trace emitted to the console, with the parent span being the automatically created one.
Metrics:
Modify app.pyto include code that initializes a meter and uses it to create a counter instrument:
Text
from opentelemetry import trace
from opentelemetry import metrics

from random import randint
from flask import Flask

tracer = trace.get_tracer(“diceroller.tracer”)

meter = metrics.get_meter(“diceroller.meter”)

roll_counter = meter.create_counter(
 “roll_counter”,
 description=”The number of rolls by roll value”,
)

app = Flask(__name__)

@app.route(“/rolldice”)
def roll_dice():
 return str(do_roll())

def do_roll():
 with tracer.start_as_current_span(“do_roll”) as rollspan:
  res = randint(1, 6)
  rollspan.set_attribute(“roll.value”, res)
  roll_counter.add(1, {“roll.value”: res})
  return res
from opentelemetry import trace
from opentelemetry import metrics

from random import randint
from flask import Flask

tracer = trace.get_tracer(“diceroller.tracer”)

meter = metrics.get_meter(“diceroller.meter”)

roll_counter = meter.create_counter(
 “roll_counter”,
 description=”The number of rolls by roll value”,
)

app = Flask(__name__)

@app.route(“/rolldice”)
def roll_dice():
 return str(do_roll())

def do_roll():
 with tracer.start_as_current_span(“do_roll”) as rollspan:
  res = randint(1, 6)
  rollspan.set_attribute(“roll.value”, res)
  roll_counter.add(1, {“roll.value”: res})
  return res
﻿
2. Run the app again:
Text
opentelemetry-instrument \
 -- traces_exporter console \
 -- metrics_exporter console \
flask run -p 8080
opentelemetry-instrument \
 -- traces_exporter console \
 -- metrics_exporter console \
flask run -p 8080
﻿
When you send a request to the server, you’ll see the roll counter metric emitted to the console, counting the number of rolls for each roll value.
Step 7: Sending Telemetry to an OpenTelemetry Collector
In most production deployments, it’s beneficial to use an OpenTelemetry Collector. Follow these steps to configure and run a local collector.
Create a file named otel-collector-config.yaml in the /tmp/ directory and save the following configuration code to it:
Text
receivers:
 otlp:
  protocols:
   grpc:
exporters:
 logging:
  loglevel: debug
 otlphttp:
    endpoint: https://otel.kloudmate.com:4318
    headers:
      Authorization: <YOUR_KM_SECRET_KEY>
processors:
 batch:
service:
 pipelines:
  traces:
   receivers: [otlp]
   exporters: [logging, otlphttp]
   processors: [batch]
metrics:
   receivers: [otlp]
   exporters: [logging, otlphttp]
   processors: [batch]
receivers:
 otlp:
  protocols:
   grpc:
exporters:
 logging:
  loglevel: debug
 otlphttp:
    endpoint: https://otel.kloudmate.com:4318
    headers:
      Authorization: <YOUR_KM_SECRET_KEY>
processors:
 batch:
service:
 pipelines:
  traces:
   receivers: [otlp]
   exporters: [logging, otlphttp]
   processors: [batch]
metrics:
   receivers: [otlp]
   exporters: [logging, otlphttp]
   processors: [batch]
﻿
 The otlphttp exporter in config.yml, along with the KloudMate API-Key as the Authorization header will send the data from the collector to KloudMate.
2. Run the following Docker command to start the collector using the configuration file:
Text
docker run -p 4317:4317 \
 -v /tmp/otel-collector-config.yaml:/etc/otel-collector-config.yaml \ otel/opentelemetry-collector:latest \
 -- config=/etc/otel-collector-config.yaml
docker run -p 4317:4317 \
 -v /tmp/otel-collector-config.yaml:/etc/otel-collector-config.yaml \ otel/opentelemetry-collector:latest \
 -- config=/etc/otel-collector-config.yaml
﻿
3. Modify the command to export spans and metrics via OTLP by installing the OTLP exporter package:
Text
pip install opentelemetry-exporter-otlp
pip install opentelemetry-exporter-otlp
﻿
4. Run the application again, but this time it will export telemetry data to the collector via OTLP:
Text
opentelemetry-instrument flask run -p 8080
opentelemetry-instrument flask run -p 8080
﻿
By default, the application will export traces and metrics over OTLP/gRPC to the collector running on localhost:4317.
Conclusion
Remember, OpenTelemetry offers various options for automatic instrumentation, manual instrumentation, and exporting telemetry data. Explore the official documentation to delve deeper into these topics and further enhance your observability capabilities.
﻿
﻿
﻿
Source URL for the example application: https://opentelemetry.io/docs/instrumentation/python/getting-started/﻿
Did this page help you?
Using OpenTelemetry SDKs
OTel For Go
Docs powered by Archbee
TABLE OF CONTENTS
Conclusion