Mapped everything on tracing support to metrics

Author: Bruno Rodrigues

graphql-spring-boot-autoconfigure/build.gradle

@@ -18,6 +18,8 @@
  */
 
 dependencies {
+    annotationProcessor "org.springframework.boot:spring-boot-configuration-processor:$LIB_SPRING_BOOT_VER"
+
     compileOnly "org.springframework.boot:spring-boot-configuration-processor:$LIB_SPRING_BOOT_VER"
 
     compile "org.springframework.boot:spring-boot-autoconfigure:$LIB_SPRING_BOOT_VER"

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/GraphQLInstrumentationAutoConfiguration.java

@@ -1,5 +1,7 @@
 package com.oembedler.moon.graphql.boot;
 
+import com.oembedler.moon.graphql.boot.metrics.MetricsInstrumentation;
+import com.oembedler.moon.graphql.boot.metrics.TracingNoResolversInstrumentation;
 import graphql.analysis.MaxQueryComplexityInstrumentation;
 import graphql.analysis.MaxQueryDepthInstrumentation;
 import graphql.execution.instrumentation.tracing.TracingInstrumentation;
@@ -30,13 +32,23 @@ public class GraphQLInstrumentationAutoConfiguration {
     @Value("${graphql.servlet.maxQueryDepth:#{null}}")
     private Integer maxQueryDepth;
 
+    @Value("${graphql.servlet.tracing-enabled:#{false}}")
+    private Boolean tracingEnabled;
+
     @Bean
     @ConditionalOnMissingBean
     @ConditionalOnProperty(value = "graphql.servlet.tracing-enabled", havingValue = "true")
     public TracingInstrumentation tracingInstrumentation() {
         return new TracingInstrumentation();
     }
 
+    @Bean
+    @ConditionalOnMissingBean
+    @ConditionalOnProperty(value = "graphql.servlet.tracing-enabled", havingValue = "false")
+    public TracingNoResolversInstrumentation tracingNoResolversInstrumentation() {
+        return new TracingNoResolversInstrumentation();
+    }
+
     @Bean
     @ConditionalOnMissingBean
     @ConditionalOnProperty(value = "graphql.servlet.max-query-complexity")
@@ -53,10 +65,10 @@ public MaxQueryDepthInstrumentation maxQueryDepthInstrumentation() {
 
     @Bean
     @ConditionalOnProperty(value = "graphql.servlet.actuator-metrics", havingValue = "true")
-    @ConditionalOnBean(MeterRegistry.class)
+    @ConditionalOnBean({MeterRegistry.class, TracingInstrumentation.class})
     @ConditionalOnMissingBean
     public MetricsInstrumentation metricsInstrumentation(MeterRegistry meterRegistry) {
-        return new MetricsInstrumentation(meterRegistry);
+        return new MetricsInstrumentation(meterRegistry, tracingEnabled);
     }
 
 }

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/GraphQLWebAutoConfiguration.java

@@ -22,6 +22,7 @@
 import com.fasterxml.jackson.databind.InjectableValues;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.oembedler.moon.graphql.boot.error.GraphQLErrorHandlerFactory;
+import com.oembedler.moon.graphql.boot.metrics.MetricsInstrumentation;
 import graphql.execution.AsyncExecutionStrategy;
 import graphql.execution.ExecutionStrategy;
 import graphql.execution.SubscriptionExecutionStrategy;
@@ -47,6 +48,7 @@
 import org.springframework.web.servlet.config.annotation.CorsRegistryWorkaround;
 
 import javax.servlet.MultipartConfigElement;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -182,6 +184,9 @@ public GraphQLQueryInvoker queryInvoker(ExecutionStrategyProvider executionStrat
                 .withExecutionStrategyProvider(executionStrategyProvider);
 
         if (instrumentations != null) {
+
+            //Metrics instrumentation should be the last to run (we need that from TracingInstrumentation)
+            Collections.sort(instrumentations, (a,b) -> a instanceof MetricsInstrumentation ? 1 : 0);
             builder.with(instrumentations);
         }
 

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/MetricsInstrumentation.java

@@ -0,0 +1,92 @@
+package com.oembedler.moon.graphql.boot.metrics;
+
+import graphql.ExecutionResult;
+import graphql.execution.instrumentation.parameters.InstrumentationExecutionParameters;
+import graphql.execution.instrumentation.tracing.TracingInstrumentation;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Timer;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author Bruno Rodrigues
+ */
+public class MetricsInstrumentation extends TracingInstrumentation {
+
+    private MeterRegistry meterRegistry;
+
+    private static final String QUERY_TIME_METRIC_NAME = "graphql.timer.query";
+    private static final String RESOLVER_TIME_METRIC_NAME = "graphql.timer.resolver";
+    private static final String OPERATION_NAME_TAG = "operationName";
+    private static final String OPERATION = "operation";
+    private static final String UNKNOWN_OPERATION_NAME = "unknown";
+    private static final String PARENT = "parent";
+    private static final String FIELD = "field";
+    private static final String TIMER_DESCRIPTION = "Timer that records the time to fetch the data by Operation Name";
+
+    private Boolean tracingEnabled;
+
+    public MetricsInstrumentation(MeterRegistry meterRegistry, Boolean tracingEnabled) {
+        this.meterRegistry = meterRegistry;
+        this.tracingEnabled = tracingEnabled;
+    }
+
+    @Override
+    public CompletableFuture<ExecutionResult> instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters) {
+
+        if (executionResult.getExtensions() != null && executionResult.getExtensions().containsKey("tracing")) {
+
+            Map<String, Object> tracingData = (Map<String, Object>) executionResult.getExtensions().get("tracing");
+            Timer executionTimer = buildQueryTimer(parameters.getOperation(), "execution");
+            executionTimer.record((long) tracingData.get("duration"), TimeUnit.NANOSECONDS);
+
+            //These next 2 ifs might not run if the document is cached on the document provider
+            if (tracingData.containsKey("validation") && ((Map<String, Object>)tracingData.get("validation")).containsKey("duration")) {
+                Timer validationTimer = buildQueryTimer(parameters.getOperation(), "validation");
+                validationTimer.record((long) ((Map<String, Object>)tracingData.get("validation")).get("duration"), TimeUnit.NANOSECONDS);
+            }
+            if (tracingData.containsKey("parsing") && ((Map<String, Object>)tracingData.get("parsing")).containsKey("duration")) {
+                Timer parsingTimer = buildQueryTimer(parameters.getOperation(), "parsing");
+                parsingTimer.record((long) ((Map<String, Object>)tracingData.get("parsing")).get("duration"), TimeUnit.NANOSECONDS);
+            }
+
+            if (((Map<String, String>)tracingData.get("execution")).containsKey("resolvers")) {
+
+                ((List<Map<String, Object>>)((Map<String, Object>)tracingData.get("execution")).get("resolvers")).forEach(field -> {
+
+                    Timer fieldTimer = buildFieldTimer(parameters.getOperation(), "resolvers", (String)field.get("parentType"), (String)field.get("fieldName"));
+                    fieldTimer.record((long) field.get("duration"), TimeUnit.NANOSECONDS);
+
+                });
+
+            }
+
+            if (!tracingEnabled) {
+                executionResult.getExtensions().remove("tracing");
+            }
+        }
+
+        return CompletableFuture.completedFuture(executionResult);
+    }
+
+    private Timer buildQueryTimer(String operationName, String operation) {
+        return Timer.builder(QUERY_TIME_METRIC_NAME)
+                .description(TIMER_DESCRIPTION)
+                .tag(OPERATION_NAME_TAG, operationName != null ? operationName : UNKNOWN_OPERATION_NAME)
+                .tag(OPERATION, operation)
+                .register(meterRegistry);
+    }
+
+    private Timer buildFieldTimer(String operationName, String operation, String parent, String field) {
+        return Timer.builder(RESOLVER_TIME_METRIC_NAME)
+                .description(TIMER_DESCRIPTION)
+                .tag(OPERATION_NAME_TAG, operationName != null ? operationName : UNKNOWN_OPERATION_NAME)
+                .tag(PARENT, parent)
+                .tag(FIELD, field)
+                .tag(OPERATION, operation)
+                .register(meterRegistry);
+    }
+}

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/metrics/MetricsInstrumentation.java

@@ -0,0 +1,14 @@
+package com.oembedler.moon.graphql.boot.metrics;
+
+import graphql.execution.instrumentation.InstrumentationContext;
+import graphql.execution.instrumentation.SimpleInstrumentationContext;
+import graphql.execution.instrumentation.parameters.InstrumentationFieldFetchParameters;
+import graphql.execution.instrumentation.tracing.TracingInstrumentation;
+
+public class TracingNoResolversInstrumentation extends TracingInstrumentation {
+
+    @Override
+    public InstrumentationContext<Object> beginFieldFetch(InstrumentationFieldFetchParameters parameters) {
+        return new SimpleInstrumentationContext<>();
+    }
+}

graphql-spring-boot-autoconfigure/src/main/java/com/oembedler/moon/graphql/boot/metrics/TracingNoResolversInstrumentation.java

@@ -1,7 +1,7 @@
 package com.oembedler.moon.graphql.boot.test.instrumentation;
 
 import com.oembedler.moon.graphql.boot.GraphQLInstrumentationAutoConfiguration;
-import com.oembedler.moon.graphql.boot.MetricsInstrumentation;
+import com.oembedler.moon.graphql.boot.metrics.MetricsInstrumentation;
 import com.oembedler.moon.graphql.boot.test.AbstractAutoConfigurationTest;
 import graphql.analysis.MaxQueryComplexityInstrumentation;
 import graphql.analysis.MaxQueryDepthInstrumentation;