HELP! Upgrade to 0.9.4: how to handle RouterResponse<BoxStream<'static, ResponseBody>> compile errors????

[golfingal72]

I had to update to 0.9.4 to get the fix for the clap issue..

I have a plugin that is working with the RouterResponse and now it won't work...

the old code looks like this and now that the RouterResponse object has changed, i don't know how to handle.. see compile errors below

           .map_response(|mut resp:RouterResponse| {

                let mut debug_query = false;
                if let Ok(Some(data)) = resp.context.get::<_, bool>("graphDebug") {
                    debug_query = data;
                }


                if (debug_query) {
                    log::info!(target: "app::debug", "Final Response: {:?}", resp);
                    log::info!(target: "app::debug", "Final Response: {:?}", resp.response.body());
                    log::info!(target: "app::debug", "Final Response Headers: {:?}", resp.response.headers());
                    log::info!(target: "app::debug", "Final Response: {:?}", resp.context);
                }

                // do any Set-Cookies for response
                if let Ok(Some(data)) = resp.context.get::<_, CookieContext>("cookie_context") {
                    if (data.has_set_cookies) {
                      let mut set_cookie_offset = 0;
                      for existing_set_cookie in data.response_set_cookies {
                         match existing_set_cookie {
                           Some(value) => {

                             let hv = HeaderValue::from_str(&value).unwrap();
                             resp.response.headers_mut().append("Set-Cookie", hv);
                         },
                         None => {}
                      }
                      set_cookie_offset += 1;
                    }
                  }
                }

                let transaction_id = resp.context.get::<_, String>("transaction_id").unwrap().unwrap_or("bugaboo".to_string()).to_string();

                if let Ok(Some(mut timer)) = resp.context.get::<_, GraphTimer>(&transaction_id) {
                  timer.status = Some(resp.response.status().as_u16());
                  match resp.response.body() {
                    ResponseBody::RawJSON(_) => {}
                    ResponseBody::GraphQL(res) => {
                       match &res.data {
                        Some(data) => timer.len = Some(data.to_string().len() as u64),
                        None => ()
                      }
                    }
                    ResponseBody::Text(_) => {}
                  }
                  timer.print_timer();
                }

    |
446 |                     log::info!(target: "app::debug", "Final Response: {:?}", resp);
    |                                                                              ^^^^ `dyn futures::Stream<Item = ResponseBody> + std::marker::Send` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
    |
    = help: the trait `std::fmt::Debug` is not implemented for `dyn futures::Stream<Item = ResponseBody> + std::marker::Send`
    = note: this error originates in the macro `format_args` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0277]: `dyn futures::Stream<Item = ResponseBody> + std::marker::Send` doesn't implement `std::fmt::Debug`
   --> src/plugins/shopstyle_interceptor.rs:447:78
    |
447 |                     log::info!(target: "app::debug", "Final Response: {:?}", resp.response.body());
    |                                                                              ^^^^^^^^^^^^^^^^^^^^ `dyn futures::Stream<Item = ResponseBody> + std::marker::Send` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
    |
    = help: the trait `std::fmt::Debug` is not implemented for `dyn futures::Stream<Item = ResponseBody> + std::marker::Send`
    = note: this error originates in the macro `format_args` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> src/plugins/shopstyle_interceptor.rs:475:21
    |
474 |                   match resp.response.body() {
    |                         -------------------- this expression has type `&Pin<Box<dyn futures::Stream<Item = ResponseBody> + std::marker::Send>>`
475 |                     ResponseBody::RawJSON(_) => {}
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `Pin`, found enum `ResponseBody`

[golfingal72]

ping o0Ignition0o

[golfingal72]

all i'm trying to do is to get the size of the response... is there another way to do it???

[o0Ignition0o]

Sure, I'll try to write an example that showcases this!

In the meantime, you can revert to v0.9.3 if you pin the dependency to clap:

apollo-router = { git = "https://github.com/apollographql/router.git", tag = "v0.9.3" }
clap = "=3.1.18"

Let me know if pinning the dependency worked for you, and I'll be happy to provide better examples soon!

[golfingal72]

I think i have a workaround for getting the length...

I really want to upgrade because the api has changed and i'll end up having to do it so i can get upcoming enhancements

[golfingal72]

My workound would work except the whole execution order got flipped around where the map_response is called prior to subgraph execution... this is not a good thing.... and basically a show stopper...

[o0Ignition0o]

    fn router_service(
        &mut self,
        service: BoxService<
            RouterRequest,
            RouterResponse<BoxStream<'static, ResponseBody>>,
            BoxError,
        >,
    ) -> BoxService<RouterRequest, RouterResponse<BoxStream<'static, ResponseBody>>, BoxError> {
        ServiceBuilder::new()
            .service(service)
            .map_response(|router_response| {
                if let Ok(Some(true)) = router_response.context.get::<_, bool>("debug") {
                    tracing::info!("debug mode!");

                    // let's play with the headers!
                    let headers = router_response
                        .response
                        .headers()
                        .iter()
                        .map(|(key, value)| format!("{}: {:?}", key.to_string(), value))
                        .collect::<Vec<_>>()
                        .join(" ");
                    tracing::info!("headers are: {:?}", headers);

                    // we can now transform the router_response!
                    router_response
                        .map(|response| {
                            response.map(|body| {
                                tracing::info!("got body! {:?}", body);
                                body
                            })
                        })
                        .boxed()
                } else {
                    router_response.boxed()
                }
            })
            .boxed()
    }

is an attempt to log the body, which I ll clean up tomorrow. It should be helpful in the meantime.

I paired it with

    fn execution_service(
        &mut self,
        service: BoxService<
            ExecutionRequest,
            ExecutionResponse<BoxStream<'static, Response>>,
            BoxError,
        >,
    ) -> BoxService<ExecutionRequest, ExecutionResponse<BoxStream<'static, Response>>, BoxError>
    {
        ServiceBuilder::new()
            .service(service)
            .map_response(|response| {
                response.context.insert("debug", true).unwrap();
                response
            })
            .boxed()
    }

and the logs show that I'm in debug mode, which means the execution service has inserted "true" in the context:

ignition@ignition-apollo my_example % cargo r -- -s ./supergraph.graphql -c ./router.yaml 
    Finished dev [unoptimized + debuginfo] target(s) in 0.50s
     Running `target/debug/router -s ./supergraph.graphql -c ./router.yaml`
2022-06-14T21:29:43.167165Z  INFO apollo_router::executable: Apollo Router v0.9.4 // (c) Apollo Graph, Inc. // Licensed as ELv2 (https://go.apollo.dev/elv2)
2022-06-14T21:29:43.271119Z  INFO apollo_router::router: starting Apollo Router
2022-06-14T21:29:44.042528Z  INFO router::plugins::test_plugin: true
2022-06-14T21:29:44.200173Z  INFO apollo_router::axum_http_server_factory: GraphQL endpoint exposed at http://127.0.0.1:4000/ 🚀
2022-06-14T21:30:13.433047Z  INFO request{method=POST uri=/ version=HTTP/1.1 otel.kind=server otel.status_code=}:router{query="query Me {\n  me {\n    name\n  }\n}" operation_name="Me" client_name="ignition" client_version="test" otel.kind=internal}: router::plugins::test_plugin: debug mode!
2022-06-14T21:30:13.433169Z  INFO request{method=POST uri=/ version=HTTP/1.1 otel.kind=server otel.status_code=}:router{query="query Me {\n  me {\n    name\n  }\n}" operation_name="Me" client_name="ignition" client_version="test" otel.kind=internal}: router::plugins::test_plugin: headers are: ""
2022-06-14T21:30:13.883533Z  INFO request{method=POST uri=/ version=HTTP/1.1 otel.kind=server otel.status_code=}: router::plugins::test_plugin: got body! GraphQL(Response { label: None, data: Some(Object({"me": Object({"name": String("Ada Lovelace")})})), path: None, errors: [], extensions: {} })

Happy to elaborate and work out a cleaner example tomorrow, in the meantime you can see the example I'm using for local tests in this repository

I hope it helps!

[o0Ignition0o]

This repository provides you with a working example of stream management, with more advanced things such as dealing with context