How to Use Prometheus Metrics with Rust

Operations Observability
2026-04-17T12:05:42+00:00
Integrate Prometheus metrics into Rust Axum apps using the metrics crate and a dedicated middleware to track request latency and counts.

Use the metrics crate to record request data and metrics-exporter-prometheus to expose a /metrics endpoint on a separate port.

use axum::{extract::{MatchedPath, Request}, middleware::{self, Next}, response::IntoResponse, routing::get, Router};
use metrics_exporter_prometheus::{Matcher, PrometheusBuilder, PrometheusHandle};
use std::{future::ready, time::{Duration, Instant}};

fn metrics_app() -> Router {
    let recorder_handle = setup_metrics_recorder();
    Router::new().route("/metrics", get(move || ready(recorder_handle.render())))
}

fn main_app() -> Router {
    Router::new()
        .route("/fast", get(|| async {}))
        .route("/slow", get(|| async { tokio::time::sleep(Duration::from_secs(1)).await; }))
        .route_layer(middleware::from_fn(track_metrics))
}

async fn track_metrics(req: Request, next: Next) -> impl IntoResponse {
    let start = Instant::now();
    let path = if let Some(matched_path) = req.extensions().get::<MatchedPath>() {
        matched_path.as_str().to_owned()
    } else {
        req.uri().path().to_owned()
    };
    let method = req.method().clone();
    let response = next.run(req).await;
    let latency = start.elapsed().as_secs_f64();
    let status = response.status().as_u16().to_string();
    let labels = [("method", method.to_string()), ("path", path), ("status", status)];
    metrics::counter!("http_requests_total", &labels).increment(1);
    metrics::histogram!("http_requests_duration_seconds", &labels).record(latency);
    response
}

fn setup_metrics_recorder() -> PrometheusHandle {
    const EXPONENTIAL_SECONDS: &[f64] = &[0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0];
    let recorder_handle = PrometheusBuilder::new()
        .set_buckets_for_metric(Matcher::Full("http_requests_duration_seconds".to_string()), EXPONENTIAL_SECONDS)
        .unwrap()
        .install_recorder()
        .unwrap();
    let upkeep_handle = recorder_handle.clone();
    tokio::spawn(async move { loop { tokio::time::sleep(Duration::from_secs(5)).await; upkeep_handle.run_upkeep(); } });
    recorder_handle
}

#[tokio::main]
async fn main() {
    let (_main_server, _metrics_server) = tokio::join!(
        async { axum::serve(tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap(), main_app()).await },
        async { axum::serve(tokio::net::TcpListener::bind("127.0.0.1:3001").await.unwrap(), metrics_app()).await }
    );
}

Add metrics = "0.24" and metrics-exporter-prometheus = "0.18" to your Cargo.toml dependencies.