Demo Prometheus Exporter

So far in this lesson we’ve used the console metric exporter for quick debugging and learning. In production, you’ll usually expose metrics to a backend such as Prometheus so you can centralize scraping, alerting, and long-term storage. Prometheus uses a pull model: your application runs a small HTTP endpoint (commonly /metrics) and Prometheus (or a collector) scrapes that endpoint via HTTP GET on a schedule.

Prometheus scrapes metrics by pulling them from your application. To integrate with Prometheus you run a small HTTP server in your app that serves the /metrics endpoint (the Prometheus client library provides this for you).

This guide shows how to configure OpenTelemetry to expose metrics via the Prometheus exporter, create a few instruments, and hook everything into a Flask app.

What you’ll set up

Start a Prometheus-compatible metrics server inside your app (so Prometheus can scrape /metrics).
Configure the OpenTelemetry PrometheusMetricReader.
Register counters, gauges, and a histogram (with explicit buckets).
Expose application endpoints (Flask) and record metrics on request lifecycle hooks.

Prerequisites

Install the Prometheus exporter and the Prometheus client:

pip install opentelemetry-exporter-prometheus prometheus-client

Full example: Flask + OpenTelemetry + Prometheus

Save the following as main.py. It contains imports, configuration, a small Flask app, and the instruments used by the application:

# main.py
import time
import random
from flask import Flask, request

from opentelemetry.metrics import set_meter_provider, get_meter_provider
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.view import ExplicitBucketHistogramAggregation, View
from opentelemetry.sdk.metrics.export import ConsoleMetricExporter, PeriodicExportingMetricReader
from opentelemetry.sdk.resources import Resource
from opentelemetry.exporter.prometheus import PrometheusMetricReader
from prometheus_client import start_http_server

app = Flask(__name__)

def configure_meter():
    # Start an HTTP server to expose Prometheus metrics (port 8000 on localhost).
    # Prometheus will scrape this endpoint (e.g., http://localhost:8000/metrics).
    start_http_server(port=8000, addr="localhost")

    # Use the PrometheusMetricReader so metrics are available to Prometheus.
    reader = PrometheusMetricReader()

    # Histogram bucket boundaries are in milliseconds in this example.
    buckets = [0.0, 20, 30, 60, 100, 250, 2000]
    view = View(
        instrument_name="total_request_duration",
        aggregation=ExplicitBucketHistogramAggregation(boundaries=buckets),
    )

    provider = MeterProvider(metric_readers=[reader], resource=Resource.create(), views=[view])
    set_meter_provider(provider)

    # Return a meter for use by the application
    return get_meter_provider().get_meter(name="shopping-app", version="0.1.2")

meter = configure_meter()

# Create instruments
requests_counter = meter.create_counter(
    name="http_requests_total",
    description="Total number of requests processed by the application",
)
concurrent_requests = meter.create_up_down_counter(
    name="concurrent_requests",
    description="Total number of requests in progress",
)
total_request_duration = meter.create_histogram(
    name="total_request_duration",
    description="Request Duration",
    unit="ms",
)

# Flask request hooks to record metrics
@app.before_request
def before_request():
    request.start_time = time.time()
    concurrent_requests.add(1)

@app.after_request
def after_request(response):
    # Convert latency to milliseconds
    request_latency_ms = (time.time() - request.start_time) * 1000
    concurrent_requests.add(-1)
    total_request_duration.record(request_latency_ms)
    return response

@app.get("/products")
def get_products():
    requests_counter.add(1, {"route": "/products", "method": request.method})
    time.sleep(random.uniform(0.05, 1.5))
    return "Get All Products"

@app.get("/products/<int:id>")
def get_product(id):
    requests_counter.add(1, {"route": "/products/<id>", "method": request.method})
    time.sleep(random.uniform(0.05, 1.5))
    return f"Getting product detail {id}"

if __name__ == "__main__":
    # Start the Flask app on port 5000
    app.run(host="0.0.0.0", port=5000)

If you want Prometheus (running on another host or in a container) to scrape your app, bind the metrics server to an address accessible to Prometheus. In the example above start_http_server(port=8000, addr="localhost") binds to localhost—change to 0.0.0.0 or the appropriate host if external scraping is required.

Key parts explained

Component	Purpose	Example / Notes
Prometheus metrics server	Exposes `/metrics` for Prometheus to scrape	`start_http_server(port=8000, addr="localhost")`
Metric Reader	Makes OpenTelemetry metrics available to Prometheus	`PrometheusMetricReader()`
Views & Aggregation	Apply bucket boundaries to histograms	`View(..., aggregation=ExplicitBucketHistogramAggregation(boundaries=buckets))`
Instruments	Counters, gauges and histograms used by the app	`http_requests_total`, `concurrent_requests`, `total_request_duration`

Notes on the example:

start_http_server(port=8000, addr="localhost") (from the Prometheus client library) serves metrics at http://localhost:8000/metrics.
PrometheusMetricReader() bridges OpenTelemetry metrics to the Prometheus client server.
The View with ExplicitBucketHistogramAggregation configures histogram bucket boundaries for total_request_duration (milliseconds).

Exercise the application and inspect metrics

Start the Flask app:
python main.py

Send a few requests to the Flask app (port 5000):

curl 127.0.0.1:5000/products
curl 127.0.0.1:5000/products
curl 127.0.0.1:5000/products

Request the metrics endpoint exposed for Prometheus (port 8000):
curl localhost:8000/metrics

You should see Prometheus-formatted metrics similar to the excerpt below:

# HELP concurrent_requests Total number of requests in progress
# TYPE concurrent_requests gauge
concurrent_requests 0.0

# HELP http_requests_total Total number of requests processed by the application
# TYPE http_requests_total counter
http_requests_total{method="GET",route="/products"} 3.0

# HELP total_request_duration_milliseconds Request Duration
# TYPE total_request_duration_milliseconds histogram
total_request_duration_milliseconds_bucket{le="0.0"} 0.0
total_request_duration_milliseconds_bucket{le="20.0"} 1.0
total_request_duration_milliseconds_bucket{le="30.0"} 2.0
total_request_duration_milliseconds_bucket{le="60.0"} 3.0
total_request_duration_milliseconds_bucket{le="100.0"} 3.0
total_request_duration_milliseconds_bucket{le="250.0"} 3.0
total_request_duration_milliseconds_bucket{le="2000.0"} 3.0
total_request_duration_milliseconds_count 3.0
total_request_duration_milliseconds_sum 214.5

This output shows:

Runtime and Python default metrics (if enabled),
Your application counters and gauge (http_requests_total, concurrent_requests),
Histogram buckets, count, and sum for total_request_duration (milliseconds).

Summary

To expose OpenTelemetry metrics to Prometheus:

Start a Prometheus-compatible metrics server in your app (prometheus_client.start_http_server).
Configure PrometheusMetricReader with your MeterProvider (and views for histograms).
Register counters / gauges / histograms and record metrics via request hooks or application code.
Point Prometheus to the app’s /metrics endpoint (or use a scraping sidecar / collector).

Demo Prometheus Exporter

What you’ll set up

Prerequisites

Full example: Flask + OpenTelemetry + Prometheus

Key parts explained

Exercise the application and inspect metrics

Summary

Links and References

Watch Video

Practice Lab

​What you’ll set up

​Prerequisites

​Full example: Flask + OpenTelemetry + Prometheus

​Key parts explained

​Exercise the application and inspect metrics

​Summary

​Links and References

Watch Video

Practice Lab

What you’ll set up

Prerequisites

Full example: Flask + OpenTelemetry + Prometheus

Key parts explained

Exercise the application and inspect metrics

Summary

Links and References