Introduction

Prometheus is commonly used to monitor infrastructure components — Linux or Windows servers, Docker containers, the Docker Engine, and similar systems. To get visibility into the behaviour of the software running on that infrastructure, you instrument the application itself and expose metrics that Prometheus can scrape.

A Prometheus client library makes it straightforward to add instrumentation to your application so Prometheus can collect application-level metrics. Client libraries typically perform two responsibilities:

Record metrics in the Prometheus exposition format using metric primitives such as Counter, Gauge, Histogram, and Summary.
Expose those metrics at an HTTP endpoint (commonly /metrics) so Prometheus can scrape them.

Prometheus maintains official client libraries for Go, Java, Python, and Ruby. Many community-maintained libraries exist for other languages (for example, Rust and Node.js). If needed, you can also implement a minimal custom client to support an unsupported language or to reduce dependencies.

If you’re not familiar with Python, focus on what metrics are being added and what they measure. The instrumentation concepts — metric types, labels, and the /metrics endpoint — apply across languages and frameworks.

Prometheus metric primitives

Understanding the main metric types helps you choose the right primitive for each signal you want to record.

Metric type	Purpose	Example
Counter	Monotonic counter for counting events (only increases)	`Counter('http_requests_total', 'Total HTTP requests')`
Gauge	Value that can go up or down (e.g., in-progress requests, temperature)	`Gauge('inprogress_requests', 'Current in-progress requests')`
Histogram	Buckets-based distribution of observed values (useful for request latency)	`Histogram('request_latency_seconds', 'Request latency in seconds')`
Summary	Similar to histogram, provides configurable quantiles (client-side aggregation)	`Summary('rpc_duration_seconds', 'RPC duration in seconds')`

Common client libraries

Language	Link
Go	prometheus/client_golang
Java	prometheus/client_java
Python	prometheus/client_python
Ruby	prometheus/client_ruby
Node.js (community)	prom-client
Rust (community)	prometheus

Example: instrumenting a Python API

Below is a minimal example showing how to instrument a Python Flask API using the official prometheus_client library. It demonstrates:

Defining a Counter and Histogram
Incrementing the counter and observing latency
Exposing metrics at /metrics for Prometheus to scrape

Install the library:

pip install prometheus_client flask

Python instrumentation example:

from time import time
from prometheus_client import Counter, Histogram, generate_latest, CONTENT_TYPE_LATEST
from flask import Flask, Response, request

REQUESTS = Counter('app_requests_total', 'Total HTTP requests', ['method', 'endpoint'])
REQUEST_LATENCY = Histogram('app_request_latency_seconds', 'Request latency in seconds', ['endpoint'])

app = Flask(__name__)

@app.before_request
def start_timer():
    request._start_time = time()

@app.after_request
def record_metrics(response):
    endpoint = request.endpoint or 'unknown'
    method = request.method
    latency = time() - getattr(request, '_start_time', time())
    REQUESTS.labels(method=method, endpoint=endpoint).inc()
    REQUEST_LATENCY.labels(endpoint=endpoint).observe(latency)
    return response

@app.route('/hello')
def hello():
    return 'Hello, world!'

@app.route('/metrics')
def metrics():
    return Response(generate_latest(), mimetype=CONTENT_TYPE_LATEST)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Prometheus can then scrape http://<host>:5000/metrics to collect these application-level metrics.

Avoid exposing sensitive information via metrics and be mindful of cardinality when using labels (high-cardinality labels can cause high memory use in Prometheus). Prefer a limited set of stable label values.

Next steps and references

Instrument critical endpoints and business transactions first (requests, errors, latency, queue depth).
Keep label cardinality low and stable.
Combine application metrics with infrastructure metrics for full-stack observability.

Links and references:

Observability Fundamentals

Prometheus Fundamentals

PromQL

Dashboarding & Visualization

Application Instrumentation

Service Discovery

Push Gateway

Alerting

Monitoring Kubernetes

Conclusion

Scaling & Long Term Storage

Introduction

Prometheus metric primitives

Common client libraries

Example: instrumenting a Python API

Next steps and references

Watch Video

​Prometheus metric primitives

​Common client libraries

​Example: instrumenting a Python API

​Next steps and references

Watch Video

Prometheus metric primitives

Common client libraries

Example: instrumenting a Python API

Next steps and references