Add tracing support

Cargo.toml

@@ -5,6 +5,7 @@ members = [
   "juniper_codegen",
   "juniper",
   "examples/basic_subscriptions",
+  "examples/tracing_support",
   "examples/warp_async",
   "examples/warp_subscriptions",
   "examples/actix_subscriptions",

docs/book/content/SUMMARY.md

@@ -25,6 +25,8 @@
     - [Hyper](servers/hyper.md)
   - [Third Party Integrations](servers/third-party.md)
 
+- [Tracing](tracing/index.md)
+
 - [Advanced Topics](advanced/index.md)
 
   - [Introspection](advanced/introspection.md)

docs/book/content/tracing/index.md

@@ -0,0 +1,66 @@
+# Tracing
+
+Juniper has optional support for the [tracing](https://crates.io/crates/tracing) crate for instrumentation.
+
+This feature is off by default and can be enabled via the `tracing` feature.
+
+!FILENAME Cargo.toml
+
+```toml
+[dependencies]
+juniper = { version = "0.14.2", features = ["default", "tracing"]}
+tracing = "0.1.17"
+tracing-subscriber = "0.2.9"
+```
+
+## Usage
+
+```rust
+# extern crate juniper;
+extern crate tokio;
+extern crate tracing;
+extern crate tracing_subscriber;
+use juniper::{EmptyMutation, EmptySubscription, RootNode, graphql_object, Variables};
+
+#[derive(Clone, Copy, Debug)]
+struct Query;
+
+#[graphql_object]
+impl Query {
+    async fn foo() -> i32 {
+        42
+    }
+}
+
+type Schema = RootNode<'static, Query, EmptyMutation<()>, EmptySubscription<()>>;
+
+
+#[tokio::main]
+async fn main() {
+    // Set up the tracing subscriber.
+    let subscriber = tracing_subscriber::fmt()
+        // This enables standard env variables such as `RUST_LOG=trace`.
+        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+        // This makes it so we can see all span events.
+        .with_span_events(tracing_subscriber::fmt::format::FmtSpan::FULL)
+        .finish();
+
+    tracing::subscriber::set_global_default(subscriber)
+        .expect("Setting default tracing subscriber failed");
+
+    // Set up GraphQL information.
+    let vars = Variables::new();
+    let root = Schema::new(
+        Query,
+        EmptyMutation::<()>::new(),
+        EmptySubscription::<()>::new(),
+    );
+
+    // When run with `RUST_LOG=trace cargo run`, this should output traces /
+    // span events to `stdout`.
+    let query = "{ foo }";
+    let (_, _errors) = juniper::execute(query, None, &root, &vars, &())
+        .await
+        .unwrap();
+}
+```

docs/book/tests/Cargo.toml

@@ -6,19 +6,23 @@ authors = ["Magnus Hallin <[email protected]>"]
 build = "build.rs"
 
 [dependencies]
-juniper = { path = "../../../juniper" }
+juniper = { path = "../../../juniper", features = ["default", "tracing"] }
 juniper_iron = { path = "../../../juniper_iron" }
 juniper_subscriptions = { path = "../../../juniper_subscriptions" }
 
 derive_more = "0.99"
 futures = "0.3"
+tokio = { version = "0.2", features = ["rt-core", "blocking", "stream", "rt-util", "macros"] }
 iron = "0.5"
 mount = "0.4"
 skeptic = "0.13"
 serde_json = "1.0"
 tokio = { version = "0.2", features = ["blocking", "macros", "rt-core", "rt-util", "stream"] }
 uuid = "0.8"
 
+tracing = "0.1.21"
+tracing-subscriber = "0.2.12"
+
 [build-dependencies]
 skeptic = "0.13"
 

examples/tracing_support/.gitignore

@@ -0,0 +1,4 @@
+/target/
+**/*.rs.bk
+Cargo.lock
+

examples/tracing_support/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "tracing_support"
+version = "0.1.0"
+authors = ["Christian Legnitto <[email protected]>"]
+edition = "2018"
+publish = false
+
+[dependencies]
+tracing = "0.1.21"
+tracing-subscriber = "0.2.12"
+# Note instead of a path you would use the proper Juniper version in your own
+# project.
+juniper = { path = "../../juniper", features = ["tracing"] }
+tokio = { version = "0.2.22", features = ["rt-core", "macros", "blocking"] }

examples/tracing_support/Makefile.toml

@@ -0,0 +1,20 @@
+[tasks.run]
+disabled = true
+
+[tasks.release]
+disabled = true
+
+[tasks.release-some]
+disabled = true
+
+[tasks.release-local-test]
+disabled = true
+
+[tasks.release-some-local-test]
+disabled = true
+
+[tasks.release-dry-run]
+disabled = true
+
+[tasks.release-some-dry-run]
+disabled = true

examples/tracing_support/src/main.rs

@@ -0,0 +1,121 @@
+extern crate juniper;
+extern crate tokio;
+extern crate tracing;
+extern crate tracing_subscriber;
+
+use juniper::{
+    graphql_object, EmptyMutation, EmptySubscription, FieldError, GraphQLEnum, RootNode, Variables,
+};
+use tracing::{trace_span, Instrument as _};
+use tracing_subscriber::EnvFilter;
+
+#[derive(Clone, Copy, Debug)]
+struct Context;
+impl juniper::Context for Context {}
+
+#[derive(Clone, Copy, Debug, GraphQLEnum)]
+enum UserKind {
+    Admin,
+    User,
+    Guest,
+}
+
+#[derive(Clone, Debug)]
+struct User {
+    id: i32,
+    kind: UserKind,
+    name: String,
+}
+
+#[graphql_object(Context = Context)]
+impl User {
+    fn id(&self) -> i32 {
+        self.id
+    }
+
+    fn kind(&self) -> UserKind {
+        self.kind
+    }
+
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    async fn friends(&self) -> Vec<User> {
+        vec![]
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct Query;
+
+#[graphql_object(Context = Context)]
+impl Query {
+    async fn users() -> Vec<User> {
+        vec![User {
+            id: 1,
+            kind: UserKind::Admin,
+            name: "user1".into(),
+        }]
+    }
+
+    fn bob() -> User {
+        User {
+            id: 1,
+            kind: UserKind::Admin,
+            name: "Bob".into(),
+        }
+    }
+
+    /// Double the provided number.
+    async fn double(x: i32) -> Result<i32, FieldError> {
+        Ok(x * 2)
+    }
+}
+
+type Schema = RootNode<'static, Query, EmptyMutation<Context>, EmptySubscription<Context>>;
+
+fn schema() -> Schema {
+    Schema::new(
+        Query,
+        EmptyMutation::<Context>::new(),
+        EmptySubscription::<Context>::new(),
+    )
+}
+
+#[tokio::main]
+async fn main() {
+    // A builder for `FmtSubscriber`.
+    let subscriber = tracing_subscriber::fmt()
+        // This enables standard env variables such as `RUST_LOG=trace`.
+        .with_env_filter(EnvFilter::from_default_env())
+        // This makes it so we can see all span events.
+        .with_span_events(tracing_subscriber::fmt::format::FmtSpan::FULL)
+        .finish();
+
+    tracing::subscriber::set_global_default(subscriber).expect("no global subscriber has been set");
+
+    let ctx = Context {};
+    let vars = Variables::new();
+    let root = schema();
+
+    // When run with `RUST_LOG=trace cargo run`, this should output to `stdout`.
+    let query = "{ users { id } }";
+    let (_, _errors) = juniper::execute(query, None, &root, &vars, &ctx)
+        .await
+        .unwrap();
+
+    // When run with `RUST_LOG=trace cargo run`, this should output to `stdout`.
+    // Note that there is a top-level span of "doubling{42}" as it was set
+    // here. This is useful to attach context to each call to `execute`.
+    let query = "{ double(x: 42) }";
+    let (_, _errors) = juniper::execute(query, None, &root, &vars, &ctx)
+        .instrument(trace_span!("doubling", "{}", 42))
+        .await
+        .unwrap();
+
+    // You can also trace sync execution.
+    // This should output a validation error in the middle of other spans.
+    let query = "{ bob { field_that_does_not_exist } }";
+    let _ = juniper::execute_sync(query, None, &root, &vars, &ctx);
+}

juniper/Cargo.toml

@@ -50,6 +50,8 @@ static_assertions = "1.1"
 url = { version = "2.0", optional = true }
 uuid = { version = "0.8", default-features = false, optional = true }
 
+tracing = { version = "0.1.21", optional = true }
+
 [dev-dependencies]
 bencher = "0.1.2"
 pretty_assertions = "0.6.1"