integrating with Sentry

[oerhahon]

When using apollo getaway I normally integrate the apollo-server with Sentry using this plugin:

import { ApolloError } from 'apollo-server-express'
import * as Sentry from '@sentry/node'

export const graphQLLogging = {
  requestDidStart() {
    return {
      didEncounterErrors(ctx: any) {
        if (!ctx.operation) {
          return
        }

        for (const err of ctx.errors) {
          if (err instanceof ApolloError) {
            continue
          }

          Sentry.withScope((scope) => {
            scope.setTag('kind', ctx.operation.operation)
            scope.setExtra('query', ctx.request.query)
            scope.setExtra('variables', ctx.request.variables)

            if (err.path) {
              scope.addBreadcrumb({
                category: 'query-path',
                message: err.path.join(' > '),
                level: 'debug'
              })
            }

            const transactionId = ctx.request.http.headers.get('x-transaction-id')
            if (transactionId) {
              scope.setTransactionName(transactionId)
            }

            Sentry.captureException(err)
          })
        }
      }
    }
  }
} 

I'm migrating to the apollo router and I want to do the same thing. I'm trying to build a new plugin but I can't figure out how to translate the previous apollo server lifecycle hooks to the router hooks. can someone please help me out?

#[derive(Debug)]
struct RouterLogger {
    #[allow(dead_code)]
    dsn: String
}

#[derive(Deserialize, JsonSchema)]
struct RouterLoggerConfig {
    dsn: String
}

#[async_trait::async_trait]
impl Plugin for RouterLogger {
    type Config = RouterLoggerConfig;

    async fn new(configuration: Self::Config) -> Result<Self, BoxError> {
        let RouterLoggerConfig { dsn } = configuration;
        let sentry_dsn = dsn.clone();
       // init sentry
        let _guard = sentry::init((sentry_dsn, sentry::ClientOptions {
            release: sentry::release_name!(),
            ..Default::default()
        }));
    }
}

register_plugin!(
    "logging",
    "router_logger",
    RouterLogger
);

[bnjjj]

In your example above you should keep the guard in RouterLogger if it's really a guard it needs to be kept during the lifecycle of the plugin and then in the struct RouterLogger.
Regarding your example in js you can use the router_service method provided by the Plugin trait. This method is taking a BoxService<RouterRequest, RouterResponse<BoxStream<'static, ResponseBody>>, BoxError> which means you can access the request and the generated response thanks to a .map_request and a .map_response.

Here is a small example of what you could have:

fn router_service(
    &mut self,
    service: BoxService<
        RouterRequest,
        RouterResponse<BoxStream<'static, ResponseBody>>,
        BoxError,
    >,
) -> BoxService<RouterRequest, RouterResponse<BoxStream<'static, ResponseBody>>, BoxError> {
    service
        .map_request(|req: RouterRequest| {
            req.context
                .insert(
                    "kind",
                    req.originating_request.body().operation_name.clone(),
                )
                .unwrap();
            // insert other elements you need from the request in the context here
            req
        })
        .map_response(|res: RouterResponse<BoxStream<'static, ResponseBody>>| {
            // Get all the element you put in the context, specify the type to deserialize
            let kind: Option<Option<String>> = res.context.get("kind").unwrap();

            res.map(move |resp| {
                resp.map(|response_body| match response_body {
                    ResponseBody::GraphQL(response) => {
                        for err in &response.errors {
                            sentry::with_scope(
                                |scope| scope.set_tag(kind.unwrap()),
                                || sentry::capture_error(err),
                            );
                        }
                    }
                    _ => response_body,
                })
            })
            .boxed()
        })
        .boxed()
}

Let me know if it helps

[oerhahon]

@bnjjj thanks for responding. I'm currently trying to test out this solution, but I'm new to rust and having issues compiling the code.

ServiceBuilder::new()
            .map_request(|req: RouterRequest| {
                req.context
                    .insert(
                        "kind",
                        req.originating_request.body().operation_name.clone(),
                    ).unwrap();
                req.context
                    .insert(
                        "query",
                        req.originating_request.body().query.clone(),
                    ).unwrap();
                req.context
                    .insert(
                        "variables",
                        req.originating_request.body().variables.clone(),
                    ).unwrap();
                req
            })
            .service(service)
            .map_response(|router_response| {
                let kind: Option<Option<String>> = router_response.context.get("kind").unwrap();
                let query: Option<Option<String>> = router_response.context.get("query").unwrap();
                let variables: Option<Option<String>> = router_response.context.get("variables").unwrap();

                router_response.map(|response| {
                   response.map(move |body| {
                    println!("got execution response body! {:?}", body.unwrap())
                   });
                }).boxed();
            })
            .boxed()

This is the error:

response.map(move |body| {
#14 317.6     |                               ^^^ `Pin<Box<dyn futures::Stream<Item = ResponseBody> + std::marker::Send>>` is not an iterator

[bnjjj]

@oerhahon sorry for the delay I was off these last days. Here is a fixed version of your code.

        ServiceBuilder::new()
            .map_request(|req: RouterRequest| {
                req.context
                    .insert(
                        "kind",
                        req.originating_request.body().operation_name.clone(),
                    )
                    .unwrap();
                req.context
                    .insert("query", req.originating_request.body().query.clone())
                    .unwrap();
                req.context
                    .insert(
                        "variables",
                        req.originating_request.body().variables.clone(),
                    )
                    .unwrap();
                req
            })
            .service(service)
            .map_response(|router_response| {
                let kind: Option<String> = router_response.context.get("kind").unwrap();
                let query: Option<String> = router_response.context.get("query").unwrap();
                let variables: Object =
                    router_response.context.get("variables").unwrap();

                router_response
                    .map(|response| {
                        response.map(move |body| {
                            println!("got execution response body! {:?}", body);

                            body
                        })
                    })
                    .boxed();
            })
            .boxed();

I just updated few things into map_response and I also changed the type you get from the context. As you're already unwraping you just fetch the same type you added in the context. Feel free to ask questions if needed

[oerhahon]

Hi @bnjjj, thanks for the help.

I successfully built the plug-in using the code and the router itself works fine.

However, errors are still not sent to Sentry. I think it has to do with your previous comment:

In your example above you should keep the guard in RouterLogger if it's really a guard it needs to be kept during the lifecycle of the plugin and then in the struct RouterLogger.

Yes, it is a guard. But I'm struggling to understand this, please can you explain this with a code sample?

Also, will apollo_router support sentry for telemetry collection in the future?

[bnjjj]

About the guard you just need to store it in your plugin struct here:

#[derive(Debug)]
struct RouterLogger {
    #[allow(dead_code)]
    dsn: String,
   _my_guard: sentry::Guard
}

and no we do not plan for now to add the support of sentry in our telemetry collection. For now we focus our efforts to provide the best experience for opentelemetry support as it's like a standard for telemetry. Maybe some tools already exist to collect metrics/traces from opentelemetry to Sentry. Let me know if it helps you.