Struct `OriginalUri`

struct OriginalUri(2266)

Extractor that gets the original request URI regardless of nesting.

This is necessary since Uri, when used as an extractor, will have the prefix stripped if used in a nested service.

Example

use axum::{
    routing::get,
    Router,
    extract::OriginalUri,
    http::Uri
};

let api_routes = Router::new()
    .route(
        "/users",
        get(|uri: Uri, OriginalUri(original_uri): OriginalUri| async {
            // `uri` is `/users`
            // `original_uri` is `/api/users`
        }),
    );

let app = Router::new().nest("/api", api_routes);
# let _: Router = app;

Extracting via request extensions

OriginalUri can also be accessed from middleware via request extensions. This is useful for example with Trace to create a span that contains the full path, if your service might be nested:

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

let api_routes = 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::<OriginalUri>() {
                // This will include `/api`
                path.0.path().to_owned()
            } else {
                // The `OriginalUri` extension will always be present if using
                // `Router` unless another extractor or middleware has removed it
                req.uri().path().to_owned()
            };
            tracing::info_span!("http-request", %path)
        }),
    );

let app = Router::new().nest("/api", api_routes);
# let _: Router = app;

Implementations

`impl Clone for OriginalUri`

fn clone(self: &Self) -> OriginalUri

`impl Debug for OriginalUri`

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

`impl Deref for OriginalUri`

fn deref(self: &Self) -> &<Self as >::Target

`impl DerefMut for OriginalUri`

fn deref_mut(self: &mut Self) -> &mut <Self as >::Target

`impl Freeze for OriginalUri`

`impl RefUnwindSafe for OriginalUri`

`impl Send for OriginalUri`

`impl Sync for OriginalUri`

`impl Unpin for OriginalUri`

`impl UnsafeUnpin for OriginalUri`

`impl UnwindSafe for OriginalUri`

`impl<P, T> Receiver for OriginalUri`

`impl<S> FromRequestParts for OriginalUri`

async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, <Self as >::Rejection>

`impl<S, T> FromRequest for OriginalUri`

fn from_request(req: Request<Body>, state: &S) -> impl Future<Output = Result<T, <T as FromRequest<S, ViaParts>>::Rejection>>

`impl<T> Any for OriginalUri`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for OriginalUri`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for OriginalUri`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for OriginalUri`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for OriginalUri`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> FromRef for OriginalUri`

fn from_ref(input: &T) -> T

`impl<T> Instrument for OriginalUri`

`impl<T> Same for OriginalUri`

`impl<T> ToOwned for OriginalUri`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T> WithSubscriber for OriginalUri`

`impl<T, U> Into for OriginalUri`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for OriginalUri`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for OriginalUri`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

`impl<V, T> VZip for OriginalUri`

fn vzip(self: Self) -> V