Struct BaseMetricLayer

pub struct BaseMetricLayer<'a> { /* private fields */ }

The tower middleware layer for recording HTTP metrics.

Unlike GenericMetricLayer, this struct does not know about the metrics exporter, or the recorder. It will only emit metrics via the metrics crate’s macros. It’s entirely up to the user to set the global metrics recorder/exporter before using this.

You may use this if GenericMetricLayer’s requirements are too strict for your use case.

Implementations

impl<'a> BaseMetricLayer<'a>

pub fn new() -> Self

Construct a new BaseMetricLayer.

Example

use axum::{routing::get, Router};
use axum_prometheus::{AXUM_HTTP_REQUESTS_DURATION_SECONDS, utils::SECONDS_DURATION_BUCKETS, BaseMetricLayer};
use metrics_exporter_prometheus::{Matcher, PrometheusBuilder};
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
   // Initialize the recorder as you like.
    let metric_handle = PrometheusBuilder::new()
       .set_buckets_for_metric(
           Matcher::Full(AXUM_HTTP_REQUESTS_DURATION_SECONDS.to_string()),
           SECONDS_DURATION_BUCKETS,
       )
       .unwrap()
       .install_recorder()
       .unwrap();

    let app = Router::<()>::new()
      .route("/fast", get(|| async {}))
      .route(
          "/slow",
          get(|| async {
              tokio::time::sleep(std::time::Duration::from_secs(1)).await;
          }),
      )
      // Expose the metrics somehow to the outer world.
      .route("/metrics", get(|| async move { metric_handle.render() }))
      // Only need to add this layer at the end.
      .layer(BaseMetricLayer::new());

   // Run the server as usual:
   // let listener = tokio::net::TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 3000)))
   //     .await
   //     .unwrap();
   // axum::serve(listener, app).await.unwrap()
}

pub fn with_response_body_size() -> Self

Construct a new BaseMetricLayer with response body size tracking enabled.

Trait Implementations

impl<'a> Clone for BaseMetricLayer<'a>

fn clone(&self) -> BaseMetricLayer<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Default for BaseMetricLayer<'a>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, S> Layer<S> for BaseMetricLayer<'a>

type Service = LifeCycle<S, SharedClassifier<StatusInRangeAsFailures>, Traffic<'a>, Option<BodySizeRecorder>>

The wrapped service

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.