Changes following the review

Author: marcingrzejszczak

micrometer-core/src/main/java/io/micrometer/core/instrument/binder/okhttp3/OkHttpDocumentedObservation.java

@@ -60,7 +60,7 @@ static Observation of(@NonNull ObservationRegistry registry, @NonNull OkHttpCont
             @Nullable Observation.ObservationConvention<OkHttpContext> customConvention) {
         Observation.ObservationConvention<OkHttpContext> convention = null;
         if (registry.isNoop()) {
-            convention = Observation.ObservationConvention.noOp();
+            return Observation.NOOP;
         }
         else if (customConvention != null) {
             convention = customConvention;

micrometer-core/src/main/java/io/micrometer/core/instrument/binder/okhttp3/OkHttpMetricsEventListener.java

@@ -67,7 +67,7 @@ public class OkHttpMetricsEventListener extends EventListener {
 
     private final ObservationRegistry observationRegistry;
 
-    private final Observation.ObservationConvention<OkHttpContext> keyValuesProvider;
+    private final Observation.ObservationConvention<OkHttpContext> observationConvention;
 
     private final String requestsMetricName;
 
@@ -96,14 +96,14 @@ protected OkHttpMetricsEventListener(MeterRegistry registry, String requestsMetr
     }
 
     OkHttpMetricsEventListener(MeterRegistry registry, ObservationRegistry observationRegistry,
-            Observation.ObservationConvention<OkHttpContext> keyValuesProvider, String requestsMetricName,
+            Observation.ObservationConvention<OkHttpContext> observationConvention, String requestsMetricName,
             Function<Request, String> urlMapper, Iterable<Tag> extraTags,
             Iterable<BiFunction<Request, Response, Tag>> contextSpecificTags, Iterable<String> requestTagKeys,
             boolean includeHostTag) {
         this.registry = registry;
         this.observationRegistry = observationRegistry;
         this.observationRegistryNoOp = observationRegistry.isNoop();
-        this.keyValuesProvider = keyValuesProvider;
+        this.observationConvention = observationConvention;
         this.requestsMetricName = requestsMetricName;
         this.urlMapper = urlMapper;
         this.extraTags = extraTags;
@@ -173,7 +173,7 @@ public Object unwrap() {
             });
         }
         Observation observation = OkHttpDocumentedObservation
-                .of(this.observationRegistry, okHttpContext, requestsMetricName, this.keyValuesProvider).start();
+                .of(this.observationRegistry, okHttpContext, requestsMetricName, this.observationConvention).start();
         callState.setContext(okHttpContext);
         callState.setObservation(observation);
         this.callState.put(call, callState);

micrometer-observation/src/main/java/io/micrometer/observation/Observation.java

@@ -762,17 +762,6 @@ interface KeyValuesConvention {
     interface ObservationConvention<T extends Observation.Context>
             extends Observation.KeyValuesProvider<T>, KeyValuesConvention {
 
-        /**
-         * Convenience method for creating no-op implementations that are of proper types.
-         * That way you don't have to do casting on your side.
-         * @return observation convention
-         * @param <T> context type
-         */
-        @SuppressWarnings("unchecked")
-        static <T extends Observation.Context> ObservationConvention<T> noOp() {
-            return (ObservationConvention<T>) NoopObservationConvention.INSTANCE;
-        }
-
         /**
          * Allows to override the name for an observation.
          * @return the new name for the observation

micrometer-observation/src/main/java/io/micrometer/observation/SimpleObservation.java

@@ -17,11 +17,11 @@
 
 import io.micrometer.common.KeyValue;
 import io.micrometer.common.lang.Nullable;
+import io.micrometer.common.util.StringUtils;
 
 import java.util.ArrayDeque;
 import java.util.Collection;
 import java.util.Deque;
-import java.util.List;
 import java.util.stream.Collectors;
 
 /**
@@ -55,13 +55,15 @@ class SimpleObservation implements Observation {
                 .filter(handler -> handler.supportsContext(this.context))
                 .collect(Collectors.toCollection(ArrayDeque::new));
         this.filters = registry.observationConfig().getObservationFilters();
-        List<ObservationConvention<?>> observationConventions = registry.observationConfig().getObservationConventions()
-                .stream().filter(observationConvention -> observationConvention.supportsContext(this.context))
-                .collect(Collectors.toList());
-        if (!observationConventions.isEmpty()) {
-            this.keyValuesProviders.addAll(observationConventions);
-            this.context.setName(observationConventions.get(0).getName());
-        }
+        registry.observationConfig().getObservationConventions().stream()
+                .filter(observationConvention -> observationConvention.supportsContext(this.context)).findFirst()
+                .ifPresent(convention -> {
+                    this.keyValuesProviders.add(convention);
+                    String newName = convention.getName();
+                    if (StringUtils.isNotBlank(newName)) {
+                        this.context.setName(newName);
+                    }
+                });
     }
 
     SimpleObservation(ObservationConvention<?> convention, ObservationRegistry registry, Context context) {
@@ -78,9 +80,14 @@ class SimpleObservation implements Observation {
 
     private static String name(ObservationConvention<?> convention, Context context) {
         if (!convention.supportsContext(context)) {
-            throw new IllegalStateException("Convention [" + convention + "] can't support context [" + context + "]");
+            throw new IllegalStateException(
+                    "Convention [" + convention + "] doesn't support context [" + context + "]");
+        }
+        String name = convention.getName();
+        if (StringUtils.isNotBlank(name)) {
+            return name;
         }
-        return convention.getName();
+        return context.getName();
     }
 
     @Override