Cannot construct router in trait

[appetrosyan]

Summary

I have a peculiar situation. I want to implement a semi-generic interface that abstracts some boilerplate and I'm having trouble with one of the limitations imposed by axum. Specifically, I have a trait that looks like this

pub trait AxumPrometheusMetricsServer {
    fn gather_metrics() -> Vec<prometheus::proto::MetricFamily>;

    async fn telemetry_handler() -> axum::response::Response {
        use axum::response::IntoResponse as _;

        let mut buffer = String::new();

        let metrics = Self::gather_metrics();
        prometheus::TextEncoder::new()
            .encode_utf8(&metrics, &mut buffer)
            .map_or_else(
                |e| (axum::http::StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
                |()| (axum::http::StatusCode::OK, buffer),
            )
            .into_response()
    }

    fn root_router() -> axum::Router {
        axum::Router::new().route("/", axum::routing::get(Self::telemetry_handler))
    }
}

Applying #[axum::debug_handler] to the telemetry_handler associated function simply tells me that I can't use Self from outer scope. I don't quite understand why this limitation comes about, to me when I implement this trait for a concrete type, Self::gather_metrics will get resolved, and I know for a fact that a function with this signature works as a handler, because this is taken directly from a boilerplate-laden part of code that I'm trying to abstract.

Can you advise as to what I can do in this situation? Failing that, can you at least explain why I can't capture Self from the point of view of the type system.

axum version

0.7.5

[jplatte]

Hi!

I think the problem is likely with trait implementations being allowed to override async fn telemetry_handler with an async fn whose Future type does not implement Send. That error about Self is unrelated, it's just a consequence of how debug_handler works internally - unfortunately you can't use it in a trait impl where the async fn calls an associated function of the same trait (I think).

The fix here should be to change the definition of telemetry_handler to

    fn telemetry_handler(
    ) -> impl std::future::Future<Output = axum::response::Response> + Send {
        async {
            use axum::response::IntoResponse as _;

            let mut buffer = String::new();

            let metrics = Self::gather_metrics();
            prometheus::TextEncoder::new()
                .encode_utf8(&metrics, &mut buffer)
                .map_or_else(
                    |e| (axum::http::StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
                    |()| (axum::http::StatusCode::OK, buffer),
                )
                .into_response()
        }
    }

[jplatte]

As an alternative, if you only care that users can call MyMetricsServer::root_router, not MyMetricsServer::telemetry_handler, you can move the telemetry handler out of the trait:

pub trait AxumPrometheusMetricsServer {
    fn gather_metrics() -> Vec<prometheus::proto::MetricFamily>;

    fn root_router() -> axum::Router {
        axum::Router::new().route("/", axum::routing::get(telemetry_handler::<Self>))
    }
}

// This logic can't be overridden by implementors of AxumPrometheusMetricsServer
async fn telemetry_handler<S>() -> axum::response::Response
where
    S: AxumPrometheusMetricsServer,
{
    use axum::response::IntoResponse as _;

    let mut buffer = String::new();

    let metrics = S::gather_metrics();
    prometheus::TextEncoder::new()
        .encode_utf8(&metrics, &mut buffer)
        .map_or_else(
            |e| (axum::http::StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
            |()| (axum::http::StatusCode::OK, buffer),
        )
        .into_response()
}

[appetrosyan]

That was actually it! The first answer specifically. The problem was something that is usually shown as a lint.

I should mention that you also need a where Self: 'static bound on the trait itself, which is not exactly a huge problem, most metric servers need to exist for the lifetime of the program anyway.

[appetrosyan]

On that note, you could include this in the #[debug_handler] macro. Capturing Self itself is not a problem, the issue is that if you're doing this in a trait, and using the async trait MVP, which doesn't allow auto-trait implementations to show up, this will cause the problem.

The main issue is that the future not being Send didn't come up in any of the error messages. I discovered your original solution independently by getting rid of the Self::gather_metrics call and then accidentally getting because I was using clippy and not check for Rust analyzer.

I should say that this is a bit of a problem.

Would you accept a PR that adds the extra info to the diagnostics reported by the macro? I'm fairly competent with procedural macros.

[jplatte]

It it's just a small addition to the macro, absolutely.