feat: add dataLoader instrumentation configuration to server (#1423)

### 📝 Description
Auto Configuration (**disabled** by default) to enable `DataLoaderLevelDispatchedInstrumentation`, `DataLoaderLevelDispatchedInstrumentation` instances to the GraphQLContext that will be used as a context for all ExecutionInput in a `GraphQLBatchRequest`

This way client only responsibility will be opt it or opt out from the optional instrumentations

```yml
graphql:
  batching: 
   enabled: true # or false 
   strategy: LEVEL_DISPATCHED # or SYNC_EXHAUSTION
```

Author: samuelAndalon

examples/server/ktor-server/src/main/kotlin/com/expediagroup/graphql/examples/server/ktor/KtorDataLoaderRegistryFactory.kt

@@ -16,6 +16,10 @@
 
 package com.expediagroup.graphql.examples.server.ktor
 
+import com.expediagroup.graphql.dataloader.KotlinDataLoaderRegistryFactory
+import com.expediagroup.graphql.examples.server.ktor.schema.dataloaders.BookDataLoader
+import com.expediagroup.graphql.examples.server.ktor.schema.dataloaders.CourseDataLoader
+import com.expediagroup.graphql.examples.server.ktor.schema.dataloaders.UniversityDataLoader
 import com.expediagroup.graphql.server.execution.GraphQLRequestHandler
 import com.expediagroup.graphql.server.execution.GraphQLServer
 import com.fasterxml.jackson.databind.ObjectMapper
@@ -32,7 +36,9 @@ class KtorGraphQLServer(
 ) : GraphQLServer<ApplicationRequest>(requestParser, contextFactory, requestHandler)
 
 fun getGraphQLServer(mapper: ObjectMapper): KtorGraphQLServer {
-    val dataLoaderRegistryFactory = KtorDataLoaderRegistryFactory()
+    val dataLoaderRegistryFactory = KotlinDataLoaderRegistryFactory(
+        UniversityDataLoader, CourseDataLoader, BookDataLoader
+    )
     val requestParser = KtorGraphQLRequestParser(mapper)
     val contextFactory = KtorGraphQLContextFactory()
     val graphQL = getGraphQLObject()

examples/server/ktor-server/src/main/kotlin/com/expediagroup/graphql/examples/server/ktor/KtorGraphQLServer.kt

@@ -231,6 +231,7 @@ class DataLoaderSyncExecutionExhaustedInstrumentationTest {
             """
                 fragment AstronautFragment on Astronaut { name missions { designation } }
                 fragment MissionFragment on Mission { designation }
+
                 query ComplexQuery {
                     astronauts1And2: astronauts(ids: [1, 2]) { ...AstronautFragment }
                     missions1And2: missions(ids: [1, 2]) { ...MissionFragment }

executions/graphql-kotlin-dataloader-instrumentation/src/test/kotlin/com/expediagroup/graphql/dataloader/instrumentation/syncexhaustion/DataLoaderSyncExecutionExhaustedInstrumentationTest.kt

@@ -29,8 +29,8 @@ import java.util.function.Function
  * that way we can know if all dependants of the [CompletableFuture]s were executed.
  */
 class KotlinDataLoaderRegistry(
-    private val registry: DataLoaderRegistry,
-    private val futureCacheMaps: List<KotlinDefaultCacheMap<*, *>>
+    private val registry: DataLoaderRegistry = DataLoaderRegistry(),
+    private val futureCacheMaps: List<KotlinDefaultCacheMap<*, *>> = emptyList()
 ) : DataLoaderRegistry() {
 
     private val futuresToComplete: MutableList<CompletableFuture<*>> = mutableListOf()

executions/graphql-kotlin-dataloader/src/main/kotlin/com/expediagroup/graphql/dataloader/DataLoaderRegistryFactory.kt

@@ -24,11 +24,14 @@ import org.dataloader.DataLoaderRegistry
  */
 class KotlinDataLoaderRegistryFactory(
     private val dataLoaders: List<KotlinDataLoader<*, *>>
-) : DataLoaderRegistryFactory {
+) {
 
     constructor(vararg dataLoaders: KotlinDataLoader<*, *>) : this(dataLoaders.toList())
 
-    override fun generate(): KotlinDataLoaderRegistry {
+    /**
+     * Generate [KotlinDataLoaderRegistry] to be used for GraphQL request execution.
+     */
+    fun generate(): KotlinDataLoaderRegistry {
         val futureCacheMaps = mutableListOf<KotlinDefaultCacheMap<*, *>>()
 
         val registry = DataLoaderRegistry()

executions/graphql-kotlin-dataloader/src/main/kotlin/com/expediagroup/graphql/dataloader/KotlinDataLoaderRegistry.kt

@@ -12,7 +12,7 @@ plugins {
 val jacksonVersion: String by project
 dependencies {
     api(project(path = ":graphql-kotlin-schema-generator"))
-    api(project(path = ":graphql-kotlin-dataloader"))
+    api(project(path = ":graphql-kotlin-dataloader-instrumentation"))
     api("com.fasterxml.jackson.module:jackson-module-kotlin:$jacksonVersion")
     testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:$kotlinCoroutinesVersion")
 }
@@ -50,7 +50,7 @@ tasks {
                 limit {
                     counter = "BRANCH"
                     value = "COVEREDRATIO"
-                    minimum = "0.85".toBigDecimal()
+                    minimum = "0.84".toBigDecimal()
                 }
             }
         }

executions/graphql-kotlin-dataloader/src/main/kotlin/com/expediagroup/graphql/dataloader/KotlinDataLoaderRegistryFactory.kt

@@ -16,37 +16,141 @@
 
 package com.expediagroup.graphql.server.execution
 
-import com.expediagroup.graphql.dataloader.DataLoaderRegistryFactory
+import com.expediagroup.graphql.dataloader.KotlinDataLoaderRegistry
+import com.expediagroup.graphql.dataloader.KotlinDataLoaderRegistryFactory
+import com.expediagroup.graphql.dataloader.instrumentation.level.DataLoaderLevelDispatchedInstrumentation
+import com.expediagroup.graphql.dataloader.instrumentation.level.state.ExecutionLevelDispatchedState
+import com.expediagroup.graphql.dataloader.instrumentation.syncexhaustion.DataLoaderSyncExecutionExhaustedInstrumentation
+import com.expediagroup.graphql.dataloader.instrumentation.syncexhaustion.state.SyncExecutionExhaustedState
 import com.expediagroup.graphql.generator.execution.GraphQLContext
+import com.expediagroup.graphql.server.extensions.containsMutation
+import com.expediagroup.graphql.server.extensions.isBatchDataLoaderInstrumentation
 import com.expediagroup.graphql.server.extensions.toExecutionInput
 import com.expediagroup.graphql.server.extensions.toGraphQLError
 import com.expediagroup.graphql.server.extensions.toGraphQLKotlinType
 import com.expediagroup.graphql.server.extensions.toGraphQLResponse
+import com.expediagroup.graphql.server.types.GraphQLBatchRequest
+import com.expediagroup.graphql.server.types.GraphQLBatchResponse
 import com.expediagroup.graphql.server.types.GraphQLRequest
 import com.expediagroup.graphql.server.types.GraphQLResponse
+import com.expediagroup.graphql.server.types.GraphQLServerRequest
+import com.expediagroup.graphql.server.types.GraphQLServerResponse
 import graphql.GraphQL
+import graphql.execution.instrumentation.ChainedInstrumentation
+import graphql.execution.instrumentation.Instrumentation
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.future.await
+import kotlinx.coroutines.supervisorScope
 
 open class GraphQLRequestHandler(
     private val graphQL: GraphQL,
-    private val dataLoaderRegistryFactory: DataLoaderRegistryFactory? = null
+    private val dataLoaderRegistryFactory: KotlinDataLoaderRegistryFactory? = null
 ) {
 
+    private val batchDataLoaderInstrumentationType: Class<Instrumentation>? =
+        graphQL.instrumentation?.let { instrumentation ->
+            when {
+                instrumentation is ChainedInstrumentation -> {
+                    instrumentation.instrumentations
+                        .firstOrNull(Instrumentation::isBatchDataLoaderInstrumentation)
+                        ?.javaClass
+                }
+                instrumentation.isBatchDataLoaderInstrumentation() -> instrumentation.javaClass
+                else -> null
+            }
+        }
+
     /**
      * Execute a GraphQL request in a non-blocking fashion.
      * This should only be used for queries and mutations.
      * Subscriptions require more specific server logic and will need to be handled separately.
      */
-    open suspend fun executeRequest(request: GraphQLRequest, context: GraphQLContext? = null, graphQLContext: Map<*, Any> = emptyMap<Any, Any>()): GraphQLResponse<*> {
-        // We should generate a new registry for every request
+    open suspend fun executeRequest(
+        graphQLRequest: GraphQLServerRequest,
+        context: GraphQLContext? = null,
+        graphQLContext: Map<*, Any> = emptyMap<Any, Any>()
+    ): GraphQLServerResponse {
         val dataLoaderRegistry = dataLoaderRegistryFactory?.generate()
-        val executionInput = request.toExecutionInput(context, dataLoaderRegistry, graphQLContext)
+        return when (graphQLRequest) {
+            is GraphQLRequest -> {
+                val batchGraphQLContext = graphQLContext + getBatchContext(1, dataLoaderRegistry)
+                execute(graphQLRequest, dataLoaderRegistry, context, batchGraphQLContext)
+            }
+            is GraphQLBatchRequest -> {
+                if (graphQLRequest.containsMutation()) {
+                    val batchGraphQLContext = graphQLContext + getBatchContext(1, dataLoaderRegistry)
+                    executeSequentially(graphQLRequest, dataLoaderRegistry, context, batchGraphQLContext)
+                } else {
+                    val batchGraphQLContext = graphQLContext + getBatchContext(graphQLRequest.requests.size, dataLoaderRegistry)
+                    executeConcurrently(graphQLRequest, dataLoaderRegistry, context, batchGraphQLContext)
+                }
+            }
+        }
+    }
 
-        return try {
-            graphQL.executeAsync(executionInput).await().toGraphQLResponse()
+    private suspend fun execute(
+        graphQLRequest: GraphQLRequest,
+        dataLoaderRegistry: KotlinDataLoaderRegistry?,
+        context: GraphQLContext? = null,
+        batchGraphQLContext: Map<*, Any>
+    ): GraphQLResponse<*> =
+        try {
+            graphQL.executeAsync(
+                graphQLRequest.toExecutionInput(dataLoaderRegistry, context, batchGraphQLContext)
+            ).await().toGraphQLResponse()
         } catch (exception: Exception) {
             val error = exception.toGraphQLError()
             GraphQLResponse<Any?>(errors = listOf(error.toGraphQLKotlinType()))
         }
+
+    private suspend fun executeSequentially(
+        batchRequest: GraphQLBatchRequest,
+        dataLoaderRegistry: KotlinDataLoaderRegistry?,
+        context: GraphQLContext?,
+        batchGraphQLContext: Map<*, Any>
+    ): GraphQLBatchResponse =
+        GraphQLBatchResponse(
+            batchRequest.requests.map { request ->
+                execute(request, dataLoaderRegistry, context, batchGraphQLContext)
+            }
+        )
+
+    private suspend fun executeConcurrently(
+        batchRequest: GraphQLBatchRequest,
+        dataLoaderRegistry: KotlinDataLoaderRegistry?,
+        context: GraphQLContext?,
+        batchGraphQLContext: Map<*, Any>
+    ): GraphQLBatchResponse {
+        val responses = supervisorScope {
+            batchRequest.requests.map { request ->
+                async {
+                    execute(request, dataLoaderRegistry, context, batchGraphQLContext)
+                }
+            }.awaitAll()
+        }
+        return GraphQLBatchResponse(responses)
+    }
+
+    private fun getBatchContext(
+        batchSize: Int,
+        dataLoaderRegistry: KotlinDataLoaderRegistry?
+    ): Map<*, Any> {
+        if (dataLoaderRegistry == null) {
+            return emptyMap<Any, Any>()
+        }
+
+        val batchContext = when (batchDataLoaderInstrumentationType) {
+            DataLoaderLevelDispatchedInstrumentation::class.java -> mapOf(
+                KotlinDataLoaderRegistry::class to dataLoaderRegistry,
+                ExecutionLevelDispatchedState::class to ExecutionLevelDispatchedState(batchSize)
+            )
+            DataLoaderSyncExecutionExhaustedInstrumentation::class.java -> mapOf(
+                KotlinDataLoaderRegistry::class to dataLoaderRegistry,
+                SyncExecutionExhaustedState::class to SyncExecutionExhaustedState(batchSize, dataLoaderRegistry)
+            )
+            else -> emptyMap<Any, Any>()
+        }
+        return batchContext
     }
 }