Add Observability support

Prior to this commit, metrics instrumentation was provided by Spring
Boot, using Micrometer metrics. The `Instrumentation` would publish two
timers and a counter, but would not support tracing.

This commit replaces the former with a dedicated support in Spring for
GraphQL directly. This uses the new `Observation` API from Micrometer
and publishes two observations:

* a request execution observation, with timing and tracing included
* a data fetching observation with the request execution as a parent
  observation

Closes gh-501

Author: bclozel

platform/build.gradle

@@ -10,6 +10,7 @@ dependencies {
 	api(platform("org.springframework:spring-framework-bom:${springFrameworkVersion}"))
 	api(platform("com.fasterxml.jackson:jackson-bom:2.13.4"))
 	api(platform("io.projectreactor:reactor-bom:2022.0.0-SNAPSHOT"))
+	api(platform("io.micrometer:micrometer-bom:1.10.0-SNAPSHOT"))
 	api(platform("org.springframework.data:spring-data-bom:2022.0.0-M6"))
 	api(platform("org.springframework.security:spring-security-bom:6.0.0-M7"))
 	api(platform("com.querydsl:querydsl-bom:5.0.0"))

spring-graphql/build.gradle

@@ -8,6 +8,7 @@ dependencies {
 	api 'org.springframework:spring-context'
 	implementation 'io.micrometer:context-propagation'
 
+	compileOnly 'io.micrometer:micrometer-observation'
 	compileOnly 'jakarta.annotation:jakarta.annotation-api'
 	compileOnly 'org.springframework:spring-webflux'
 	compileOnly 'org.springframework:spring-webmvc'
@@ -42,7 +43,7 @@ dependencies {
 	testImplementation 'org.springframework.data:spring-data-commons'
 	testImplementation 'org.springframework.data:spring-data-keyvalue'
 	testImplementation 'org.springframework.data:spring-data-jpa'
-	testImplementation 'io.micrometer:context-propagation'
+	testImplementation 'io.micrometer:micrometer-observation-test'
 	testImplementation 'com.h2database:h2'
 	testImplementation 'org.hibernate:hibernate-core'
 	testImplementation 'org.hibernate.validator:hibernate-validator'

spring-graphql/src/main/java/org/springframework/graphql/observation/DataFetcherObservationContext.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2020-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.graphql.observation;
+
+import graphql.schema.DataFetchingEnvironment;
+import io.micrometer.observation.Observation;
+
+/**
+ * Context that holds information for metadata collection during observations
+ * for {@link GraphQlObservationDocumentation#DATA_FETCHER data fetching operations}.
+ *
+ * @author Brian Clozel
+ * @since 1.1.0
+ */
+public class DataFetcherObservationContext extends Observation.Context {
+
+	private final DataFetchingEnvironment environment;
+
+	private Object value;
+
+	DataFetcherObservationContext(DataFetchingEnvironment environment) {
+		this.environment = environment;
+	}
+
+	/**
+	 * Return the data fetching environment provided as an input.
+	 */
+	public DataFetchingEnvironment getEnvironment() {
+		return this.environment;
+	}
+
+	/**
+	 * Return the value returned by the {@link graphql.schema.DataFetcher}, if any.
+	 * @see #getError() for the exception thrown by the data fetcher.
+	 */
+	public Object getValue() {
+		return this.value;
+	}
+
+	void setValue(Object value) {
+		this.value = value;
+	}
+}

spring-graphql/src/main/java/org/springframework/graphql/observation/DataFetcherObservationConvention.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2020-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.graphql.observation;
+
+import io.micrometer.observation.Observation;
+import io.micrometer.observation.ObservationConvention;
+
+/**
+ * Interface for an {@link ObservationConvention}
+ * for {@link GraphQlObservationDocumentation#DATA_FETCHER data fetching observations}.
+ *
+ * @author Brian Clozel
+ * @since 1.1.0
+ */
+public interface DataFetcherObservationConvention extends ObservationConvention<DataFetcherObservationContext> {
+
+
+	@Override
+	default boolean supportsContext(Observation.Context context) {
+		return context instanceof DataFetcherObservationContext;
+	}
+}

spring-graphql/src/main/java/org/springframework/graphql/observation/DefaultDataFetcherObservationConvention.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2020-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.graphql.observation;
+
+import io.micrometer.common.KeyValue;
+import io.micrometer.common.KeyValues;
+
+import org.springframework.graphql.observation.GraphQlObservationDocumentation.DataFetcherLowCardinalityKeyNames;
+
+/**
+ * Default implementation for a {@link DataFetcherObservationConvention}
+ * extracting information from a {@link DataFetcherObservationContext}.
+ *
+ * @author Brian Clozel
+ * @since 1.1.0
+ */
+public class DefaultDataFetcherObservationConvention implements DataFetcherObservationConvention {
+
+	private static final String DEFAULT_NAME = "graphql.datafetcher";
+
+	private static final KeyValue OUTCOME_SUCCESS = KeyValue.of(DataFetcherLowCardinalityKeyNames.OUTCOME, "SUCCESS");
+
+	private static final KeyValue OUTCOME_ERROR = KeyValue.of(DataFetcherLowCardinalityKeyNames.OUTCOME, "ERROR");
+
+	private static final KeyValue ERROR_TYPE_NONE = KeyValue.of(DataFetcherLowCardinalityKeyNames.ERROR_TYPE, "NONE");
+
+	private final String name;
+
+	public DefaultDataFetcherObservationConvention() {
+		this(DEFAULT_NAME);
+	}
+
+	public DefaultDataFetcherObservationConvention(String name) {
+		this.name = name;
+	}
+
+	@Override
+	public String getName() {
+		return this.name;
+	}
+
+	@Override
+	public String getContextualName(DataFetcherObservationContext context) {
+		return "graphQL field " + context.getEnvironment().getField().getName();
+	}
+
+	@Override
+	public KeyValues getLowCardinalityKeyValues(DataFetcherObservationContext context) {
+		return KeyValues.of(outcome(context), fieldName(context), errorType(context));
+	}
+
+	protected KeyValue outcome(DataFetcherObservationContext context) {
+		if (context.getError() != null) {
+			return OUTCOME_ERROR;
+		} return OUTCOME_SUCCESS;
+	}
+
+	protected KeyValue fieldName(DataFetcherObservationContext context) {
+		return KeyValue.of(DataFetcherLowCardinalityKeyNames.FIELD_NAME, context.getEnvironment().getField().getName());
+	}
+
+	protected KeyValue errorType(DataFetcherObservationContext context) {
+		if (context.getError() != null) {
+			return KeyValue.of(DataFetcherLowCardinalityKeyNames.ERROR_TYPE, context.getError().getClass().getSimpleName());
+		} return ERROR_TYPE_NONE;
+	}
+
+	@Override
+	public KeyValues getHighCardinalityKeyValues(DataFetcherObservationContext context) {
+		return KeyValues.of(fieldPath(context));
+	}
+
+	protected KeyValue fieldPath(DataFetcherObservationContext context) {
+		return KeyValue.of(GraphQlObservationDocumentation.DataFetcherHighCardinalityKeyNames.FIELD_PATH,
+				context.getEnvironment().getExecutionStepInfo().getPath().toString());
+	}
+}

spring-graphql/src/main/java/org/springframework/graphql/observation/DefaultExecutionRequestObservationConvention.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2020-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.graphql.observation;
+
+import io.micrometer.common.KeyValue;
+import io.micrometer.common.KeyValues;
+
+import org.springframework.graphql.observation.GraphQlObservationDocumentation.ExecutionRequestHighCardinalityKeyNames;
+import org.springframework.graphql.observation.GraphQlObservationDocumentation.ExecutionRequestLowCardinalityKeyNames;
+
+/**
+ * Default implementation for a {@link ExecutionRequestObservationConvention}
+ * extracting information from a {@link ExecutionRequestObservationContext}.
+ *
+ * @author Brian Clozel
+ * @since 1.1.0
+ */
+public class DefaultExecutionRequestObservationConvention implements ExecutionRequestObservationConvention {
+
+	private static final String DEFAULT_NAME = "graphql.request";
+
+	private static final String BASE_CONTEXTUAL_NAME = "graphQL ";
+
+	private static final KeyValue OUTCOME_SUCCESS = KeyValue.of(ExecutionRequestLowCardinalityKeyNames.OUTCOME, "SUCCESS");
+
+	private static final KeyValue OUTCOME_REQUEST_ERROR = KeyValue.of(ExecutionRequestLowCardinalityKeyNames.OUTCOME, "REQUEST_ERROR");
+
+	private static final KeyValue OUTCOME_INTERNAL_ERROR = KeyValue.of(ExecutionRequestLowCardinalityKeyNames.OUTCOME, "INTERNAL_ERROR");
+
+	private static final KeyValue OPERATION_QUERY = KeyValue.of(ExecutionRequestLowCardinalityKeyNames.OPERATION, "query");
+
+	private final String name;
+
+	public DefaultExecutionRequestObservationConvention() {
+		this(DEFAULT_NAME);
+	}
+
+	public DefaultExecutionRequestObservationConvention(String name) {
+		this.name = name;
+	}
+
+	@Override
+	public String getName() {
+		return this.name;
+	}
+
+	@Override
+	public String getContextualName(ExecutionRequestObservationContext context) {
+		return BASE_CONTEXTUAL_NAME + context.getCarrier().getOperationName();
+	}
+
+	@Override
+	public KeyValues getLowCardinalityKeyValues(ExecutionRequestObservationContext context) {
+		return KeyValues.of(outcome(context), operation(context));
+	}
+
+	protected KeyValue outcome(ExecutionRequestObservationContext context) {
+		if (context.getError() != null || context.getResponse() == null) {
+			return OUTCOME_INTERNAL_ERROR;
+		}
+		else if (context.getResponse().getErrors().size() > 0) {
+			return OUTCOME_REQUEST_ERROR;
+		}
+		return OUTCOME_SUCCESS;
+	}
+
+	protected KeyValue operation(ExecutionRequestObservationContext context) {
+		String operationName = context.getCarrier().getOperationName();
+		if (operationName != null) {
+			return KeyValue.of(ExecutionRequestLowCardinalityKeyNames.OPERATION, operationName);
+		}
+		return OPERATION_QUERY;
+	}
+
+	@Override
+	public KeyValues getHighCardinalityKeyValues(ExecutionRequestObservationContext context) {
+		return KeyValues.of(executionId(context));
+	}
+
+	protected KeyValue executionId(ExecutionRequestObservationContext context) {
+		return KeyValue.of(ExecutionRequestHighCardinalityKeyNames.EXECUTION_ID, context.getCarrier().getExecutionId().toString());
+	}
+
+}

spring-graphql/src/main/java/org/springframework/graphql/observation/ExecutionRequestObservationContext.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2020-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.graphql.observation;
+
+import graphql.ExecutionInput;
+import graphql.ExecutionResult;
+import io.micrometer.observation.transport.RequestReplyReceiverContext;
+
+/**
+ * Context that holds information for metadata collection during observations
+ * for {@link GraphQlObservationDocumentation#EXECUTION_REQUEST GraphQL requests}.
+ * <p>This context also extends {@link RequestReplyReceiverContext} for propagating
+ * tracing information with the HTTP server exchange.
+ *
+ * @author Brian Clozel
+ * @since 1.1.0
+ */
+public class ExecutionRequestObservationContext extends RequestReplyReceiverContext<ExecutionInput, ExecutionResult> {
+
+	public ExecutionRequestObservationContext(ExecutionInput executionInput) {
+		super((input, key) -> executionInput.getExtensions().get(key).toString());
+		setCarrier(executionInput);
+	}
+
+}

spring-graphql/src/main/java/org/springframework/graphql/observation/ExecutionRequestObservationConvention.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2020-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.graphql.observation;
+
+import io.micrometer.observation.Observation;
+import io.micrometer.observation.ObservationConvention;
+
+/**
+ * Interface for an {@link ObservationConvention} for {@link GraphQlObservationDocumentation#EXECUTION_REQUEST GraphQL requests}.
+ *
+ * @author Brian Clozel
+ * @since 1.1.0
+ */
+public interface ExecutionRequestObservationConvention extends ObservationConvention<ExecutionRequestObservationContext> {
+
+	@Override
+	default boolean supportsContext(Observation.Context context) {
+		return context instanceof ExecutionRequestObservationContext;
+	}
+
+}