OpenTelemetry Flask Instrumentation Complete Tutorial

In this article, we will use OpenTelemetry to instrument a sample Flask app for traces. Flask is one of the most popular web application frameworks of Python. It consists of Werkzeug WSGI toolkit and Jinja2 template engine.

Instrumentation is the biggest challenge engineering teams face when starting out with monitoring their application performance. OpenTelemetry is the leading open-source standard that is solving the problem of instrumentation. It is currently an incubating project under the Cloud Native Computing Foundation.

It is a set of tools, APIs, and SDKs used to instrument applications to create and manage telemetry data(Logs, metrics, and traces). It aims to make telemetry data(logs, metrics, and traces) a built-in feature of cloud-native software applications.

One of the biggest advantages of using OpenTelemetry is that it is vendor-agnostic. It can export data in multiple formats which you can send to a backend of your choice.

In this article, we will use SigNoz as a backend. SigNoz is an open-source APM tool that can be used for both metrics and distributed tracing.

Let's get started and see how to use OpenTelemetry for a Flask application.

Running a Flask application with OpenTelemetry

OpenTelemetry is a set of tools, APIs, and SDKs used to instrument applications to create and manage telemetry data(logs, metrics, and traces).

Setting up SigNoz

You need a backend to which you can send the collected data for monitoring and visualization. SigNoz is an OpenTelemetry-native APM that is well-suited for visualizing OpenTelemetry data.

SigNoz cloud is the easiest way to run SigNoz. You can sign up here for a free account and get 30 days of unlimited access to all features.

You can also install and self-host SigNoz yourself. Check out the docs for installing self-host SigNoz.

Instrumenting a sample Flask application with OpenTelemetry

Prerequisites

• Python 3.8 or newer
  Download the latest version of Python.
• MongoDB
  Below are the download links for different OS:
  MacOS
  Linux
  Windows
  Ubuntu
  

Step 1. Running sample Flask app

We will be using the Flask app at this Github repo. All the required OpenTelemetry packages are contained within the requirements.txt file.

git clone https://github.com/SigNoz/sample-flask-app.git
cd sample-flask-app

It’s a good practice to create virtual environments for running Python apps, so we will be using a virtual python environment for this sample Flask app.

Create a Virtual Environment

python3 -m venv .venv
source .venv/bin/activate

Check if the app is running

python3 app.py

You can now access the UI of the app on your local host: http://localhost:5002/

To capture data with OpenTelemetry, you need to configure some environment variables and run the app with OpenTelemetry packages. Once you ensure your app is running, stop the app with ctrl + c on a mac. Now, let us instrument the sample app with OpenTelemetry packages.

Step 2. Run instructions for sending data to SigNoz
The requirements.txt file contains all the necessary OpenTelemetry Python packages needed for instrumentation. In order to install those packages, run the following command:

python -m pip install -r requirements.txt

Step 3. Install application-specific packages

This step is required to install packages specific to the application. Make sure to run this command in the root directory of your installed application. This command figures out which instrumentation packages the user might want to install and installs it for them:

opentelemetry-bootstrap --action=install

Step 4. Configure environment variables to run app and send data to SigNoz

OTEL_RESOURCE_ATTRIBUTES=service.name=<service_name> \
OTEL_EXPORTER_OTLP_ENDPOINT="https://ingest.{region}.signoz.cloud:443" \
OTEL_EXPORTER_OTLP_HEADERS="signoz-ingestion-key=SIGNOZ_INGESTION_KEY" \
OTEL_EXPORTER_OTLP_PROTOCOL=grpc \
opentelemetry-instrument <your_run_command>

• <service_name> is the name of the service you want
• <your_run_command> can be python3 app.py or flask run
• Replace SIGNOZ_INGESTION_KEY with the api token provided by SigNoz. You can find it in the email sent by SigNoz with your cloud account details.

You will be able to get ingestion details in SigNoz cloud account under settings --> ingestion settings.

For our sample Flask application, the run command will look like:

OTEL_RESOURCE_ATTRIBUTES=service.name=flask-app \
OTEL_EXPORTER_OTLP_ENDPOINT="https://ingest.{region}.signoz.cloud:443" \
OTEL_EXPORTER_OTLP_HEADERS="signoz-ingestion-key=SIGNOZ_INGESTION_KEY" \
OTEL_EXPORTER_OTLP_PROTOCOL=grpc \
opentelemetry-instrument python app.py

And, congratulations! You have instrumented your sample Flask app. You can check if your app is running or not by hitting the endpoint at http://localhost:5002/.

You need to interact with the application to generate some monitoring data.

Below you can find your flask-app in the list of applications being monitored on SigNoz dashboard.

Troubleshooting

The debug mode can break instrumentation from happening because it enables a reloader. To run instrumentation while the debug mode is enabled, set the use_reloader option to False:

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=5002, debug=True, use_reloader=False)

If you face any problem in instrumenting with OpenTelemetry, refer to these docs.

Monitor Flask application with SigNoz

SigNoz makes it easy to visualize metrics and traces captured through OpenTelemetry instrumentation.

SigNoz comes with out of box RED metrics charts and visualization. RED metrics stands for:

• Rate of requests
• Error rate of requests
• Duration taken by requests

You can then choose a particular timestamp where latency is high to drill down to traces around that timestamp.

You can use flamegraphs to exactly identify the issue causing the latency.

You can also build custom metrics dashboard for your infrastructure.

Conclusion

OpenTelemetry makes it very convenient to instrument your Flask application. You can then use an open-source APM tool like SigNoz to analyze the performance of your app. As SigNoz offers a full-stack observability tool, you don't have to use multiple tools for your monitoring needs.

You can try out SigNoz by visiting its GitHub repo 👇

If you have any questions or need any help in setting things up, join our slack community and ping us in #support channel.

If you want to read more about SigNoz 👇

Golang Aplication Monitoring with OpenTelemetry and SigNoz

OpenTelemetry collector - complete guide