Struct MatchedPath 

pub struct MatchedPath(/* private fields */);

Access the path in the router that matches the request.

use axum::{
    Router,
    extract::MatchedPath,
    routing::get,
};

let app = Router::new().route(
    "/users/{id}",
    get(|path: MatchedPath| async move {
        let path = path.as_str();
        // `path` will be "/users/{id}"
    })
);

Accessing MatchedPath via extensions

MatchedPath can also be accessed from middleware via request extensions.

This is useful for example with Trace to create a span that contains the matched path:

use axum::{
    Router,
    extract::{Request, MatchedPath},
    routing::get,
};
use tower_http::trace::TraceLayer;

let app = Router::new()
    .route("/users/{id}", get(|| async { /* ... */ }))
    .layer(
        TraceLayer::new_for_http().make_span_with(|req: &Request<_>| {
            let path = if let Some(path) = req.extensions().get::<MatchedPath>() {
                path.as_str()
            } else {
                req.uri().path()
            };
            tracing::info_span!("http-request", %path)
        }),
    );

Implementations

impl MatchedPath

pub fn as_str(&self) -> &str

Returns a str representation of the path.

Trait Implementations

impl Clone for MatchedPath

fn clone(&self) -> MatchedPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MatchedPath

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<S> FromRequestParts<S> for MatchedPath

where S: Send + Sync,

type Rejection = MatchedPathRejection

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request_parts( parts: &mut Parts, _state: &S, ) -> Result<MatchedPath, <MatchedPath as FromRequestParts<S>>::Rejection>

Perform the extraction.

impl<S> OptionalFromRequestParts<S> for MatchedPath

where S: Send + Sync,

type Rejection = Infallible

If the extractor fails, it will use this “rejection” type.

async fn from_request_parts( parts: &mut Parts, _state: &S, ) -> Result<Option<MatchedPath>, <MatchedPath as OptionalFromRequestParts<S>>::Rejection>

Perform the extraction.