Add integration for Apollo-Kotlin 3

.github/ISSUE_TEMPLATE/bug_report_android.yml

@@ -14,6 +14,7 @@ body:
         - sentry-android-timber
         - sentry-android-fragment
         - sentry-apollo
+        - sentry-apollo-3
         - other
     validations:
       required: true

.github/ISSUE_TEMPLATE/bug_report_java.yml

@@ -12,6 +12,7 @@ body:
         - sentry-jul
         - sentry-jdbc
         - sentry-apollo
+        - sentry-apollo-3
         - sentry-kotlin-extensions
         - sentry-servlet
         - sentry-servlet-jakarta

CHANGELOG.md

@@ -21,6 +21,8 @@
 
 ## 6.1.1
 
+- Add integration for Apollo-Kotlin 3 ([#2109](https://github.com/getsentry/sentry-java/pull/2109))
+
 ### Features
 
 - Replace `tracestate` header with `baggage` header ([#2078](https://github.com/getsentry/sentry-java/pull/2078))

buildSrc/src/main/java/Config.kt

@@ -104,6 +104,8 @@ object Config {
         val graphQlJava = "com.graphql-java:graphql-java:17.3"
 
         val kotlinReflect = "org.jetbrains.kotlin:kotlin-reflect"
+
+        val apolloKotlin = "com.apollographql.apollo3:apollo-runtime:3.3.0"
     }
 
     object AnnotationProcessors {
@@ -131,7 +133,7 @@ object Config {
         val mockitoInline = "org.mockito:mockito-inline:4.3.1"
         val awaitility = "org.awaitility:awaitility-kotlin:4.1.1"
         val mockWebserver = "com.squareup.okhttp3:mockwebserver:${Libs.okHttpVersion}"
-        val mockWebserver3 = "com.squareup.okhttp3:mockwebserver:3.14.9"
+        val mockWebserver4 = "com.squareup.okhttp3:mockwebserver:4.9.3"
         val jsonUnit = "net.javacrumbs.json-unit:json-unit:2.32.0"
         val hsqldb = "org.hsqldb:hsqldb:2.6.1"
         val javaFaker = "com.github.javafaker:javafaker:1.0.2"

sentry-apollo-3/api/sentry-apollo-3.api

@@ -0,0 +1,25 @@
+public final class io/sentry/apollo3/SentryApollo3HttpInterceptor : com/apollographql/apollo3/network/http/HttpInterceptor {
+	public static final field Companion Lio/sentry/apollo3/SentryApollo3HttpInterceptor$Companion;
+	public static final field SENTRY_APOLLO_3_OPERATION_NAME Ljava/lang/String;
+	public static final field SENTRY_APOLLO_3_OPERATION_TYPE Ljava/lang/String;
+	public static final field SENTRY_APOLLO_3_VARIABLES Ljava/lang/String;
+	public fun <init> ()V
+	public fun <init> (Lio/sentry/IHub;)V
+	public fun <init> (Lio/sentry/IHub;Lio/sentry/apollo3/SentryApollo3HttpInterceptor$BeforeSpanCallback;)V
+	public synthetic fun <init> (Lio/sentry/IHub;Lio/sentry/apollo3/SentryApollo3HttpInterceptor$BeforeSpanCallback;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun dispose ()V
+	public fun intercept (Lcom/apollographql/apollo3/api/http/HttpRequest;Lcom/apollographql/apollo3/network/http/HttpInterceptorChain;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+}
+
+public abstract interface class io/sentry/apollo3/SentryApollo3HttpInterceptor$BeforeSpanCallback {
+	public abstract fun execute (Lio/sentry/ISpan;Lcom/apollographql/apollo3/api/http/HttpRequest;Lcom/apollographql/apollo3/api/http/HttpResponse;)Lio/sentry/ISpan;
+}
+
+public final class io/sentry/apollo3/SentryApollo3HttpInterceptor$Companion {
+}
+
+public final class io/sentry/apollo3/SentryApollo3RequestComposer : com/apollographql/apollo3/api/http/HttpRequestComposer {
+	public fun <init> (Ljava/lang/String;)V
+	public fun compose (Lcom/apollographql/apollo3/api/ApolloRequest;)Lcom/apollographql/apollo3/api/http/HttpRequest;
+}
+

sentry-apollo-3/build.gradle.kts

@@ -0,0 +1,79 @@
+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)
+    id(Config.BuildPlugins.buildConfig) version Config.BuildPlugins.buildConfigVersion
+}
+
+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.kotlinCompatibleLanguageVersion
+}
+
+dependencies {
+    api(projects.sentry)
+    api(projects.sentryKotlinExtensions)
+
+    implementation(Config.Libs.apolloKotlin)
+
+    compileOnly(Config.CompileOnly.nopen)
+    errorprone(Config.CompileOnly.nopenChecker)
+    errorprone(Config.CompileOnly.errorprone)
+    errorprone(Config.CompileOnly.errorProneNullAway)
+    compileOnly(Config.CompileOnly.jetbrainsAnnotations)
+
+    // tests
+    testImplementation(projects.sentryTestSupport)
+    testImplementation(Config.Libs.coroutinesCore)
+    testImplementation(kotlin(Config.kotlinStdLib))
+    testImplementation(Config.TestLibs.kotlinTestJunit)
+    testImplementation(Config.TestLibs.mockitoKotlin)
+    testImplementation(Config.TestLibs.mockitoInline)
+    testImplementation(Config.TestLibs.mockWebserver4)
+}
+
+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-apollo-3/src/main/java/io/sentry/apollo3/SentryApollo3HttpInterceptor.kt

@@ -0,0 +1,177 @@
+package io.sentry.apollo3
+
+import com.apollographql.apollo3.api.http.HttpHeader
+import com.apollographql.apollo3.api.http.HttpRequest
+import com.apollographql.apollo3.api.http.HttpResponse
+import com.apollographql.apollo3.exception.ApolloHttpException
+import com.apollographql.apollo3.exception.ApolloNetworkException
+import com.apollographql.apollo3.network.http.HttpInterceptor
+import com.apollographql.apollo3.network.http.HttpInterceptorChain
+import io.sentry.Breadcrumb
+import io.sentry.Hint
+import io.sentry.HubAdapter
+import io.sentry.IHub
+import io.sentry.ISpan
+import io.sentry.SentryLevel
+import io.sentry.SpanStatus
+import io.sentry.TracingOrigins
+import io.sentry.TypeCheckHint
+
+class SentryApollo3HttpInterceptor @JvmOverloads constructor(private val hub: IHub = HubAdapter.getInstance(), private val beforeSpan: BeforeSpanCallback? = null) :
+    HttpInterceptor {
+
+    override suspend fun intercept(
+        request: HttpRequest,
+        chain: HttpInterceptorChain
+    ): HttpResponse {
+        val activeSpan = hub.span
+        return if (activeSpan == null) {
+            chain.proceed(request)
+        } else {
+            val span = startChild(request, activeSpan)
+
+            val cleanedHeaders = removeSentryInternalHeaders(request.headers)
+
+            val requestBuilder = request.newBuilder().apply {
+                headers(cleanedHeaders)
+            }
+
+            if (TracingOrigins.contain(hub.options.tracingOrigins, request.url)) {
+                val sentryTraceHeader = span.toSentryTrace()
+                val baggageHeader = span.toBaggageHeader()
+                requestBuilder.addHeader(sentryTraceHeader.name, sentryTraceHeader.value)
+
+                baggageHeader?.let {
+                    requestBuilder.addHeader(it.name, it.value)
+                }
+            }
+
+            val modifiedRequest = requestBuilder.build()
+            var httpResponse: HttpResponse? = null
+            var statusCode: Int? = null
+
+            try {
+                httpResponse = chain.proceed(modifiedRequest)
+                statusCode = httpResponse.statusCode
+                span.status = SpanStatus.fromHttpStatusCode(statusCode, SpanStatus.UNKNOWN)
+                return httpResponse
+            } catch (e: Throwable) {
+                when (e) {
+                    is ApolloHttpException -> {
+                        statusCode = e.statusCode
+                        span.status = SpanStatus.fromHttpStatusCode(statusCode, SpanStatus.INTERNAL_ERROR)
+                    }
+                    is ApolloNetworkException -> span.status = SpanStatus.INTERNAL_ERROR
+                    else -> SpanStatus.INTERNAL_ERROR
+                }
+                span.throwable = e
+                throw e
+            } finally {
+                finish(span, modifiedRequest, httpResponse, statusCode)
+            }
+        }
+    }
+
+    private fun removeSentryInternalHeaders(headers: List<HttpHeader>): List<HttpHeader> {
+        return headers.filterNot { it.name == SENTRY_APOLLO_3_VARIABLES || it.name == SENTRY_APOLLO_3_OPERATION_NAME || it.name == SENTRY_APOLLO_3_OPERATION_TYPE }
+    }
+
+    private fun startChild(request: HttpRequest, activeSpan: ISpan): ISpan {
+        val url = request.url
+        val method = request.method
+
+        val operationName = operationNameFromHeaders(request)
+        val operation = operationName ?: "apollo.client"
+        val operationType = request.valueForHeader(SENTRY_APOLLO_3_OPERATION_TYPE) ?: method
+        val operationId = request.valueForHeader("X-APOLLO-OPERATION-ID")
+        val variables = request.valueForHeader(SENTRY_APOLLO_3_VARIABLES)
+        val description = "$operationType ${operationName ?: url}"
+
+        return activeSpan.startChild(operation, description).apply {
+            operationId?.let {
+                setData("operationId", it)
+            }
+
+            variables?.let {
+                setData("variables", it)
+            }
+        }
+    }
+
+    private fun operationNameFromHeaders(request: HttpRequest): String? {
+        return request.valueForHeader(SENTRY_APOLLO_3_OPERATION_NAME) ?: request.valueForHeader("X-APOLLO-OPERATION-NAME")
+    }
+
+    private fun HttpRequest.valueForHeader(key: String) = headers.firstOrNull { it.name == key }?.value
+
+    private fun finish(span: ISpan, request: HttpRequest, response: HttpResponse? = null, statusCode: Int?) {
+        var newSpan: ISpan = span
+        if (beforeSpan != null) {
+            try {
+                newSpan = beforeSpan.execute(span, request, response)
+            } catch (e: Throwable) {
+                hub.options.logger.log(SentryLevel.ERROR, "An error occurred while executing beforeSpan on ApolloInterceptor", e)
+            }
+        }
+        newSpan.finish()
+
+        val breadcrumb =
+            Breadcrumb.http(request.url, request.method.name, statusCode)
+
+        request.body?.contentLength.ifHasValidLength { contentLength ->
+            breadcrumb.setData("request_body_size", contentLength)
+        }
+
+        val hint = Hint().also {
+            it.set(TypeCheckHint.APOLLO_REQUEST, request)
+        }
+
+        response?.let { httpResponse ->
+            httpResponse.headersContentLength().ifHasValidLength { contentLength ->
+                breadcrumb.setData("response_body_size", contentLength)
+            }
+
+            if (!breadcrumb.data.containsKey("response_body_size")) {
+                httpResponse.body?.buffer?.size?.ifHasValidLength { contentLength ->
+                    breadcrumb.setData("response_body_size", contentLength)
+                }
+            }
+
+            hint.set(TypeCheckHint.APOLLO_RESPONSE, httpResponse)
+        }
+
+        hub.addBreadcrumb(breadcrumb, hint)
+    }
+
+    // Extensions
+
+    private fun HttpResponse.headersContentLength(): Long {
+        return headers.firstOrNull { it.name == "Content-Length" }?.value?.toLongOrNull() ?: -1L
+    }
+
+    private fun Long?.ifHasValidLength(fn: (Long) -> Unit) {
+        if (this != null && this != -1L) {
+            fn.invoke(this)
+        }
+    }
+
+    /**
+     * The BeforeSpan callback
+     */
+    fun interface BeforeSpanCallback {
+        /**
+         * Mutates span before being added.
+         *
+         * @param span the span to mutate or drop
+         * @param request the Apollo request object
+         * @param response the Apollo response object
+         */
+        fun execute(span: ISpan, request: HttpRequest, response: HttpResponse?): ISpan
+    }
+
+    companion object {
+        const val SENTRY_APOLLO_3_VARIABLES = "SENTRY-APOLLO-3-VARIABLES"
+        const val SENTRY_APOLLO_3_OPERATION_NAME = "SENTRY-APOLLO-3-OPERATION-NAME"
+        const val SENTRY_APOLLO_3_OPERATION_TYPE = "SENTRY-APOLLO-3-OPERATION-TYPE"
+    }
+}

sentry-apollo-3/src/main/java/io/sentry/apollo3/SentryApollo3RequestComposer.kt

@@ -0,0 +1,39 @@
+package io.sentry.apollo3
+
+import com.apollographql.apollo3.api.ApolloRequest
+import com.apollographql.apollo3.api.CustomScalarAdapters
+import com.apollographql.apollo3.api.Mutation
+import com.apollographql.apollo3.api.Operation
+import com.apollographql.apollo3.api.Query
+import com.apollographql.apollo3.api.Subscription
+import com.apollographql.apollo3.api.http.DefaultHttpRequestComposer
+import com.apollographql.apollo3.api.http.HttpRequest
+import com.apollographql.apollo3.api.http.HttpRequestComposer
+import com.apollographql.apollo3.api.variables
+
+class SentryApollo3RequestComposer(url: String) : HttpRequestComposer {
+    private val defaultHttpRequestComposer = DefaultHttpRequestComposer(url)
+
+    override fun <D : Operation.Data> compose(apolloRequest: ApolloRequest<D>): HttpRequest {
+        val httpRequest = defaultHttpRequestComposer.compose(apolloRequest)
+        val builder = httpRequest.newBuilder()
+            .addHeader(SentryApollo3HttpInterceptor.SENTRY_APOLLO_3_OPERATION_TYPE, operationType(apolloRequest))
+            .addHeader(SentryApollo3HttpInterceptor.SENTRY_APOLLO_3_OPERATION_NAME, apolloRequest.operation.name())
+
+        apolloRequest.scalarAdapters?.let {
+            builder.addHeader(SentryApollo3HttpInterceptor.SENTRY_APOLLO_3_VARIABLES, apolloRequest.operation.variables(it).valueMap.toString())
+        }
+
+        return builder.build()
+    }
+
+    private fun <D : Operation.Data> operationType(apolloRequest: ApolloRequest<D>) = when (apolloRequest.operation) {
+        is Query -> "query"
+        is Mutation -> "mutation"
+        is Subscription -> "subscription"
+        else -> apolloRequest.operation.javaClass.simpleName
+    }
+
+    private val <D : Operation.Data> ApolloRequest<D>.scalarAdapters
+        get() = executionContext[CustomScalarAdapters]
+}