Feat: Add graphql-java instrumentation.

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+* Feat: Add `graphql-java` instrumentation (#1777)
+
 ## 5.3.0
 
 * Feat: Add datasource tracing with P6Spy (#1784)

buildSrc/src/main/java/Config.kt

@@ -101,6 +101,10 @@ object Config {
         val apolloCoroutines = "com.apollographql.apollo:apollo-coroutines-support:$apolloVersion"
 
         val p6spy = "p6spy:p6spy:3.9.1"
+
+        val graphQlJava = "com.graphql-java:graphql-java:17.3"
+
+        val kotlinReflect = "org.jetbrains.kotlin:kotlin-reflect"
     }
 
     object AnnotationProcessors {

sentry-graphql-java/api/sentry-graphql-java.api

@@ -0,0 +1,15 @@
+public final class io/sentry/graphql/SentryDataFetcherExceptionHandler : graphql/execution/DataFetcherExceptionHandler {
+	public fun <init> (Lgraphql/execution/DataFetcherExceptionHandler;)V
+	public fun <init> (Lio/sentry/IHub;Lgraphql/execution/DataFetcherExceptionHandler;)V
+	public fun onException (Lgraphql/execution/DataFetcherExceptionHandlerParameters;)Lgraphql/execution/DataFetcherExceptionHandlerResult;
+}
+
+public final class io/sentry/graphql/SentryInstrumentation : graphql/execution/instrumentation/SimpleInstrumentation {
+	public fun <init> ()V
+	public fun <init> (Lio/sentry/IHub;)V
+	public fun beginExecution (Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;)Lgraphql/execution/instrumentation/InstrumentationContext;
+	public fun createState ()Lgraphql/execution/instrumentation/InstrumentationState;
+	public fun instrumentDataFetcher (Lgraphql/schema/DataFetcher;Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;)Lgraphql/schema/DataFetcher;
+	public fun instrumentExecutionResult (Lgraphql/ExecutionResult;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;)Ljava/util/concurrent/CompletableFuture;
+}
+

sentry-graphql-java/build.gradle.kts

@@ -0,0 +1,76 @@
+import net.ltgt.gradle.errorprone.errorprone
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    `java-library`
+    kotlin("jvm")
+    jacoco
+    id(Config.QualityPlugins.errorProne)
+    id(Config.QualityPlugins.gradleVersions)
+}
+
+configure<JavaPluginExtension> {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+    kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8.toString()
+    kotlinOptions.languageVersion = Config.springKotlinCompatibleLanguageVersion
+}
+
+dependencies {
+    api(projects.sentry)
+    implementation(Config.Libs.graphQlJava)
+
+    compileOnly(Config.CompileOnly.nopen)
+    errorprone(Config.CompileOnly.nopenChecker)
+    errorprone(Config.CompileOnly.errorprone)
+    errorprone(Config.CompileOnly.errorProneNullAway)
+    compileOnly(Config.CompileOnly.jetbrainsAnnotations)
+
+    // tests
+    testImplementation(projects.sentry)
+    testImplementation(projects.sentryTestSupport)
+    testImplementation(kotlin(Config.kotlinStdLib))
+    testImplementation(Config.TestLibs.kotlinTestJunit)
+    testImplementation(Config.TestLibs.mockitoKotlin)
+    testImplementation(Config.TestLibs.mockWebserver)
+    testImplementation(Config.Libs.okhttp)
+}
+
+configure<SourceSetContainer> {
+    test {
+        java.srcDir("src/test/java")
+    }
+}
+
+jacoco {
+    toolVersion = Config.QualityPlugins.Jacoco.version
+}
+
+tasks.jacocoTestReport {
+    reports {
+        xml.required.set(true)
+        html.required.set(false)
+    }
+}
+
+tasks {
+    jacocoTestCoverageVerification {
+        violationRules {
+            rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } }
+        }
+    }
+    check {
+        dependsOn(jacocoTestCoverageVerification)
+        dependsOn(jacocoTestReport)
+    }
+}
+
+tasks.withType<JavaCompile>().configureEach {
+    options.errorprone {
+        check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
+        option("NullAway:AnnotatedPackages", "io.sentry")
+    }
+}

sentry-graphql-java/src/main/java/io/sentry/graphql/SentryDataFetcherExceptionHandler.java

@@ -0,0 +1,36 @@
+package io.sentry.graphql;
+
+import graphql.execution.DataFetcherExceptionHandler;
+import graphql.execution.DataFetcherExceptionHandlerParameters;
+import graphql.execution.DataFetcherExceptionHandlerResult;
+import io.sentry.HubAdapter;
+import io.sentry.IHub;
+import io.sentry.util.Objects;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Captures exceptions that occur during data fetching, passes them to Sentry and invokes a delegate
+ * exception handler.
+ */
+public final class SentryDataFetcherExceptionHandler implements DataFetcherExceptionHandler {
+  private final @NotNull IHub hub;
+  private final DataFetcherExceptionHandler delegate;
+
+  public SentryDataFetcherExceptionHandler(
+      final @NotNull IHub hub, final @NotNull DataFetcherExceptionHandler delegate) {
+    this.hub = Objects.requireNonNull(hub, "hub is required");
+    this.delegate = Objects.requireNonNull(delegate, "delegate is required");
+  }
+
+  public SentryDataFetcherExceptionHandler(final @NotNull DataFetcherExceptionHandler delegate) {
+    this(HubAdapter.getInstance(), delegate);
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  public DataFetcherExceptionHandlerResult onException(
+      final @NotNull DataFetcherExceptionHandlerParameters handlerParameters) {
+    hub.captureException(handlerParameters.getException());
+    return delegate.onException(handlerParameters);
+  }
+}

sentry-graphql-java/src/main/java/io/sentry/graphql/SentryInstrumentation.java

@@ -0,0 +1,115 @@
+package io.sentry.graphql;
+
+import graphql.ExecutionResult;
+import graphql.execution.instrumentation.InstrumentationContext;
+import graphql.execution.instrumentation.InstrumentationState;
+import graphql.execution.instrumentation.SimpleInstrumentation;
+import graphql.execution.instrumentation.parameters.InstrumentationExecutionParameters;
+import graphql.execution.instrumentation.parameters.InstrumentationFieldFetchParameters;
+import graphql.schema.DataFetcher;
+import graphql.schema.GraphQLNonNull;
+import graphql.schema.GraphQLObjectType;
+import graphql.schema.GraphQLOutputType;
+import io.sentry.HubAdapter;
+import io.sentry.IHub;
+import io.sentry.ISpan;
+import io.sentry.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class SentryInstrumentation extends SimpleInstrumentation {
+  private final @NotNull IHub hub;
+
+  public SentryInstrumentation(final @NotNull IHub hub) {
+    this.hub = Objects.requireNonNull(hub, "hub is required");
+  }
+
+  public SentryInstrumentation() {
+    this(HubAdapter.getInstance());
+  }
+
+  @Override
+  public @NotNull InstrumentationState createState() {
+    return new TracingState();
+  }
+
+  @Override
+  public @NotNull InstrumentationContext<ExecutionResult> beginExecution(
+      final @NotNull InstrumentationExecutionParameters parameters) {
+    TracingState tracingState = parameters.getInstrumentationState();
+    tracingState.setTransaction(hub.getSpan());
+    return super.beginExecution(parameters);
+  }
+
+  @Override
+  @SuppressWarnings("FutureReturnValueIgnored")
+  public @NotNull DataFetcher<?> instrumentDataFetcher(
+      final @NotNull DataFetcher<?> dataFetcher,
+      final @NotNull InstrumentationFieldFetchParameters parameters) {
+    // We only care about user code
+    if (parameters.isTrivialDataFetcher()) {
+      return dataFetcher;
+    }
+
+    return environment -> {
+      final TracingState tracingState = parameters.getInstrumentationState();
+      final ISpan transaction = tracingState.getTransaction();
+      if (transaction != null) {
+        final ISpan span = transaction.startChild(findDataFetcherTag(parameters));
+        final Object result = dataFetcher.get(environment);
+        if (result instanceof CompletableFuture) {
+          ((CompletableFuture<?>) result)
+              .whenComplete(
+                  (r, ex) -> {
+                    span.finish();
+                  });
+        } else {
+          span.finish();
+        }
+        return result;
+      } else {
+        return dataFetcher.get(environment);
+      }
+    };
+  }
+
+  @Override
+  public @NotNull CompletableFuture<ExecutionResult> instrumentExecutionResult(
+      final @NotNull ExecutionResult executionResult,
+      final @NotNull InstrumentationExecutionParameters parameters) {
+    TracingState tracingState = parameters.getInstrumentationState();
+    final ISpan transaction = tracingState.getTransaction();
+
+    if (transaction != null) {
+      transaction.finish();
+    }
+
+    return super.instrumentExecutionResult(executionResult, parameters);
+  }
+
+  private @NotNull String findDataFetcherTag(
+      final @NotNull InstrumentationFieldFetchParameters parameters) {
+    final GraphQLOutputType type = parameters.getExecutionStepInfo().getParent().getType();
+    GraphQLObjectType parent;
+    if (type instanceof GraphQLNonNull) {
+      parent = (GraphQLObjectType) ((GraphQLNonNull) type).getWrappedType();
+    } else {
+      parent = (GraphQLObjectType) type;
+    }
+
+    return parent.getName() + "." + parameters.getExecutionStepInfo().getPath().getSegmentName();
+  }
+
+  static final class TracingState implements InstrumentationState {
+    private @Nullable ISpan transaction;
+
+    public @Nullable ISpan getTransaction() {
+      return transaction;
+    }
+
+    public void setTransaction(final @Nullable ISpan transaction) {
+      this.transaction = transaction;
+    }
+  }
+}

sentry-graphql-java/src/test/kotlin/io/sentry/graphql/SentryDataFetcherExceptionHandlerTest.kt

@@ -0,0 +1,25 @@
+package io.sentry.graphql
+
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.verify
+import graphql.execution.DataFetcherExceptionHandler
+import graphql.execution.DataFetcherExceptionHandlerParameters
+import io.sentry.IHub
+import kotlin.test.Test
+
+class SentryDataFetcherExceptionHandlerTest {
+
+    @Test
+    fun `passes exception to Sentry and invokes delegate`() {
+        val hub = mock<IHub>()
+        val delegate = mock<DataFetcherExceptionHandler>()
+        val handler = SentryDataFetcherExceptionHandler(hub, delegate)
+
+        val exception = RuntimeException()
+        val parameters = DataFetcherExceptionHandlerParameters.newExceptionParameters().exception(exception).build()
+        handler.onException(parameters)
+
+        verify(hub).captureException(exception)
+        verify(delegate).onException(parameters)
+    }
+}

sentry-graphql-java/src/test/kotlin/io/sentry/graphql/SentryInstrumentationTest.kt

@@ -0,0 +1,85 @@
+package io.sentry.graphql
+
+import com.nhaarman.mockitokotlin2.any
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.verify
+import com.nhaarman.mockitokotlin2.verifyNoMoreInteractions
+import com.nhaarman.mockitokotlin2.whenever
+import graphql.GraphQL
+import graphql.schema.idl.RuntimeWiring
+import graphql.schema.idl.SchemaGenerator
+import graphql.schema.idl.SchemaParser
+import io.sentry.IHub
+import io.sentry.ISpan
+import kotlin.random.Random
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class SentryInstrumentationTest {
+
+    class Fixture {
+        val transaction = mock<ISpan>()
+        val innerSpan = mock<ISpan>()
+
+        fun getSut(isTransactionActive: Boolean = true): GraphQL {
+            val schema = """
+            type Query {
+                shows: [Show]
+            }
+
+            type Show {
+                id: Int
+            }
+            """.trimIndent()
+            val hub = mock<IHub>()
+
+            val graphQLSchema = SchemaGenerator().makeExecutableSchema(SchemaParser().parse(schema), buildRuntimeWiring())
+            val graphQL = GraphQL.newGraphQL(graphQLSchema)
+                .instrumentation(SentryInstrumentation(hub))
+                .build()
+
+            if (isTransactionActive) {
+                whenever(hub.span).thenReturn(transaction)
+            } else {
+                whenever(hub.span).thenReturn(null)
+            }
+            whenever(transaction.startChild(any())).thenReturn(innerSpan)
+
+            return graphQL
+        }
+
+        private fun buildRuntimeWiring() = RuntimeWiring.newRuntimeWiring()
+            .type("Query") {
+                it.dataFetcher("shows") {
+                    listOf(Show(Random.nextInt()), Show(Random.nextInt()))
+                }
+            }.build()
+    }
+
+    private val fixture = Fixture()
+
+    @Test
+    fun `when transaction is active, creates inner spans`() {
+        val sut = fixture.getSut()
+
+        val result = sut.execute("{ shows { id } }")
+
+        assertTrue(result.errors.isEmpty())
+        verify(fixture.transaction).startChild("Query.shows")
+        verify(fixture.innerSpan).finish()
+        verify(fixture.transaction).finish()
+    }
+
+    @Test
+    fun `when transaction is not , does not create spans`() {
+        val sut = fixture.getSut(isTransactionActive = false)
+
+        val result = sut.execute("{ shows { id } }")
+
+        assertTrue(result.errors.isEmpty())
+        verifyNoMoreInteractions(fixture.transaction)
+        verifyNoMoreInteractions(fixture.innerSpan)
+    }
+
+    data class Show(val id: Int)
+}