OpenTelemetry guide for Flask and SQLAlchemy

In this article, you will learn how to use OpenTelemetry with Uptrace to monitor Flask and SQLAlchemy performance.

Uptrace


What is tracing?

Distributed tracingopen in new window allows to observe requests as they propagate through distributed systems, especially those built using a microservices architecture.

Tracing provides insights into your app performance along with any errors and logs. You immediately see what conditions cause errors and how particular error affects app performance.

Using tracing, you can break down requests into spansopen in new window. Span is an operation (unit of work) your app performs handling a request, for example, a database query or a network call.

Trace is a tree of spans that shows the path that a request makes through an app. Root span is the first span in a trace.

To learn more about tracing, see Distributed tracing using OpenTelemetryopen in new window.

What is OpenTelemetry?

OpenTelemetryopen in new window is an open-source observability framework for distributed tracingopen in new window (including logs and errors) and metricsopen in new window.

Otel allows developers to collect and export telemetry data in a vendor agnostic way. With OpenTelemetry, you can instrumentopen in new window your application once and then add or change vendors without changing the instrumentation, for example, here is a list popular DataDog alternativesopen in new window that support OpenTelemetry.

OpenTelemetry is available for most programming languages and provides interoperability across different languages and environments.

Creating spans

You can create a span using OpenTelemetry Python APIopen in new window like this:

from opentelemetry import trace

tracer = trace.get_tracer("app_or_package_name", "1.0.0")

def some_func(**kwargs):
    with tracer.start_as_current_span("some-func") as span:
        // the code you are measuring

What is Uptrace?

Uptraceopen in new window is an open source DataDog alternativeopen in new window that helps developers pinpoint failures and find performance bottlenecks. Uptrace can process billions of spans on a single server and allows to monitor your software at 10x lower cost.

You can install Uptraceopen in new window by downloading a DEB/RPM package or a pre-compiled binary.

Example application

In this tutorial, you will be instrumenting a toy appopen in new window that uses Flask and SQLAlchemy database client. You can retrieve the source code with the following command:

git clone git@github.com:uptrace/uptrace.git
cd example/flask

The app comes with some dependencies that you can install with:

pip install -r requirements.txt

Configuring OpenTelemetry

Uptrace provides OpenTelemetry Pythonopen in new window distro that configures OpenTelemetry SDK for you. To install the distro:

pip install uptrace

Then you need to initialize the distro whenever you app is started, for example, in manage.py:

# manage.py

import uptrace

def main():
    uptrace.configure_opentelemetry(
        # Copy DSN here or use UPTRACE_DSN env var.
        # dsn="",
        service_name="myservice",
        service_version="v1.0.0",
    )

    # other code

See documentationopen in new window for details.

Instrumenting Flask app

To instrument Flask app, you need to install a correspoding OpenTelemetry Flask instrumentationopen in new window:

pip install opentelemetry-instrumentation-flask

Then you can instrument the Flask app:

from opentelemetry.instrumentation.flask import FlaskInstrumentor

app = Flask(__name__)
FlaskInstrumentor().instrument_app(app)

Instrumenting SQLAlchemy

To instrument SQLAlchemy database client, you need to install a corresponding instrumentation:

pip install opentelemetry-instrumentation-sqlalchemy

Then instrument the db engine:

from flask_sqlalchemy import SQLAlchemy
from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor

app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
db = SQLAlchemy(app)
SQLAlchemyInstrumentor().instrument(engine=db.engine)

Running the example

You can start Uptrace backend with a single command using Docker exampleopen in new window:

docker-compose up -d

And then start the appopen in new window passing Uptrace DSN as an env variable:

export UPTRACE_DSN=http://project2_secret_token@localhost:14317/2
python3 main.py

The app should be serving requests on http://localhost:8000 and should render a link to Uptrace UI. After opening the link, you should see this:

Flask OpenTelemetry

What's next?

Next, you can learn about OpenTelemetry Python APIopen in new window to create your own instrumentations or browse existing instrumentationsopen in new window provided by the community.

Last Updated: