Struct rocket_prometheus::PrometheusMetrics

pub struct PrometheusMetrics { /* private fields */ }

Fairing and Handler implementing request instrumentation.

By default this tracks two metrics:

• rocket_http_requests_total (labels: endpoint, method, status): the total number of HTTP requests handled by Rocket.
• rocket_http_requests_duration_seconds (labels: endpoint, method, status): the request duration for all HTTP requests handled by Rocket.

The rocket prefix of these metrics can be changed by setting the ROCKET_PROMETHEUS_NAMESPACE environment variable.

Usage

Simply attach and mount a PrometheusMetrics instance to your Rocket app as for a normal fairing / handler:

use rocket_prometheus::PrometheusMetrics;

#[rocket::launch]
fn launch() -> _ {
    let prometheus = PrometheusMetrics::new();
    rocket::build()
        .attach(prometheus.clone())
        .mount("/metrics", prometheus)
}

Metrics will then be available on the “/metrics” endpoint:

$ curl localhost:8000/metrics
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="0.005"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="0.01"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="0.025"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="0.05"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="0.1"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="0.25"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="0.5"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="1"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="2.5"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="5"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="10"} 2
rocket_http_requests_duration_seconds_bucket{endpoint="/metrics",method="GET",status="200",le="+Inf"} 2
rocket_http_requests_duration_seconds_sum{endpoint="/metrics",method="GET",status="200"} 0.0011045669999999999
rocket_http_requests_duration_seconds_count{endpoint="/metrics",method="GET",status="200"} 2
rocket_http_requests_total{endpoint="/metrics",method="GET",status="200"} 2

Implementations

impl PrometheusMetrics

pub fn new() -> Self

Create a new PrometheusMetrics.

pub fn with_registry(registry: Registry) -> Self

Create a new PrometheusMetrics with a custom Registry.

pub fn with_default_registry() -> Self

Create a new PrometheusMetrics using the default Prometheus Registry.

This will cause the fairing to include metrics created by the various prometheus macros, e.g. register_int_counter.

pub const fn registry(&self) -> &Registry

Get the registry used by this fairing to track additional metrics.

You can use this to register further metrics, causing them to be exposed along with the default metrics on the PrometheusMetrics handler.

Note that the http_requests_total and http_requests_duration_seconds metrics are not included in this registry.

use once_cell::sync::Lazy;
use prometheus::{opts, IntCounter};
use rocket_prometheus::PrometheusMetrics;

static MY_COUNTER: Lazy<IntCounter> = Lazy::new(|| {
    IntCounter::new("my_counter", "A counter I use a lot")
        .expect("Could not create counter")
});

let prometheus = PrometheusMetrics::new();
prometheus.registry().register(Box::new(MY_COUNTER.clone()));

Trait Implementations

impl Clone for PrometheusMetrics

fn clone(&self) -> PrometheusMetrics

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for PrometheusMetrics

fn default() -> Self

Returns the “default value” for a type.

impl Fairing for PrometheusMetrics

fn info(&self) -> Info

Returns an Info structure containing the name and Kind of this fairing. The name can be any arbitrary string. Kind must be an ord set of Kind variants.

fn on_request<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request<'life2>,
    __arg2: &'life3 mut Data<'life4>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    'life4: 'async_trait,
    Self: 'async_trait, 

The request callback.

fn on_response<'r, 'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    req: &'r Request<'life1>,
    response: &'life2 mut Response<'r>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'r: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

The response callback.

fn on_ignite<'life0, 'async_trait>(
    &'life0 self,
    rocket: Rocket<Build>
) -> Pin<Box<dyn Future<Output = Result<Rocket<Build>, Rocket<Build>>> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

The ignite callback. Returns Ok if ignition should proceed and Err if ignition and launch should be aborted.

fn on_liftoff<'life0, 'life1, 'async_trait>(
    &'life0 self,
    _rocket: &'life1 Rocket<Orbit>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

The liftoff callback.

impl From<PrometheusMetrics> for Vec<Route>

fn from(other: PrometheusMetrics) -> Self

Performs the conversion.

impl Handler for PrometheusMetrics

fn handle<'r, 'life0, 'life1, 'async_trait>(
    &'life0 self,
    req: &'r Request<'life1>,
    __arg2: Data<'r>
) -> Pin<Box<dyn Future<Output = Outcome<'r>> + Send + 'async_trait>> where
    'r: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Called by Rocket when a Request with its associated Data should be handled by this handler.