async-graphql-extension-apollo-tracing 2.1.0

An async_graphql extension to send traces & metrics to Apollo Studio
docs.rs failed to build async-graphql-extension-apollo-tracing-2.1.0
Please check the build logs for more information.
See Builds for ideas on how to fix a failed build, or Metadata for how to configure docs.rs builds.
If you believe this is docs.rs' fault, open an issue.
Visit the last successful build: async-graphql-extension-apollo-tracing-0.4.2

async-graphql-extension-apollo-tracing

async-graphql-extension-apollo-tracing is an open-source extension for the crates async_graphql. The purpose of this extension is to provide a simple way to create & send your graphql metrics to Apollo Studio.

Tested at Rust version: rustc 1.56.0 (09c42c458 2021-10-18)

Apollo Studio with async_graphql

Features

  • Runtime agnostic (tokio / async-std)
  • Fully support traces & errors
  • Batched Protobuf transfer
  • Client segmentation
  • Additional data to segment your queries by visitors
  • Tracing
  • Schema export to studio
  • Error traces
  • Gzip compression

Crate features

This crate offers the following features, all of which are not activated by default:

  • compression: Enable the GZIP Compression when sending traces.
  • tokio-comp: Enable the Tokio compatibility when you have a tokio-runtime
  • async-std-comp: Enable the async-std compatibility when you have a async-std-runtime

Examples

Warp

A litle example to how to use it. If there is something unclear, please write an issue on the repo. Some examples are going to be written soon.

use async_graphql_extension_apollo_tracing::{ApolloTracing, ApolloTracingDataExt, HTTPMethod, register::register};

async fn main() -> anyhow::Result<()> {
  ...

  let schema = Schema::build(Query::default(), Mutation::default(), EmptySubscription)
    .data(some_data_needed_for_you)
    .extension(ApolloTracing::new(
      "authorization_token".into(),
      "https://yourdomain.ltd".into(),
      "your_graph@variant".into(),
      "v1.0.0".into(),
      10,
    ))
    .finish();

  register("authorization_token", &schema, "my-allocation-id", "variant", "1.0.0", "staging").await?;
  
  ...

  let client_name = warp::header::optional("apollographql-client-name");
  let client_version = warp::header::optional("apollographql-client-version");
  let env = my_env_filter();

  let graphql_post = warp::post()
      .and(warp::path("graphql"))
      .and(async_graphql_warp::graphql(schema))
      .and(env)
      .and(client_name)
      .and(client_version)
      .and_then(
          |(schema, request): (
              Schema<Query, Mutation, EmptySubscription>,
              async_graphql::Request,
          ),
           env: Environment,
           client_name: Option<String>,
           client_version: Option<String>| async move {
              let userid: Option<String> = env.userid().map(|x| x.to_string());

              Ok::<_, std::convert::Infallible>(async_graphql_warp::Response::from(
                  schema
                      .execute(
                          request.data(ApolloTracingDataExt {
                              userid,
                              path: Some("/graphql".to_string()),
                              host: Some("https://yourdomain.ltd".to_string()),
                              method: Some(HTTPMethod::POST),
                              secure: Some(true),
                              protocol: Some("HTTP/1.1".to_string()),
                              status_code: Some(200),
                              client_name,
                              client_version,
                          })
                              .data(env),
                      )
                      .await,
              ))
          },
      );



}

References