Improve no-op behavior of the Observation API (#6700)

There are four cases when an Observation can be no-op:
1. The ObservationRegistry is null
2. The ObservationRegistry is ObservationRegistry.NOOP
3. The ObservationRegistry does not have any handlers
4. An Observation is disabled by an ObservationPredicate

In the first three cases, no Observations are created.
In the last case, some Observations can be created but
some can be ignored. In this scenario, we need to support
scoping (context-propagation) but in the first three we don't.

This change makes the NoopObservation truly no-op to cover the
first three cases and introduces NoopButScopeHandlingObservation
to cover the last one.

This should result in better performance in cases where JIT
can eliminate the code because of NoopObservation being truly no-op.

Author: jonatan-ivanov

benchmarks/benchmarks-core/src/jmh/java/io/micrometer/benchmark/core/ObservationBenchmark.java

@@ -15,8 +15,6 @@
  */
 package io.micrometer.benchmark.core;
 
-import java.util.concurrent.TimeUnit;
-
 import io.micrometer.common.KeyValue;
 import io.micrometer.common.KeyValues;
 import io.micrometer.core.instrument.LongTaskTimer;
@@ -34,13 +32,17 @@
 import org.openjdk.jmh.runner.RunnerException;
 import org.openjdk.jmh.runner.options.OptionsBuilder;
 
+import java.util.concurrent.TimeUnit;
+
 @Fork(1)
 @Threads(4)
 @State(Scope.Benchmark)
 @BenchmarkMode(Mode.AverageTime)
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
 public class ObservationBenchmark {
 
+    private static final Exception error = new IllegalStateException("error");
+
     SimpleMeterRegistry meterRegistry;
 
     ObservationRegistry observationRegistry;
@@ -181,13 +183,15 @@ public ObservationOrTimerCompatibleInstrumentation<Observation.Context> observat
         return instrumentation;
     }
 
+    // This should not measure anything, JIT should figure out that the registry is noop
     @Benchmark
     public Observation noopObservation() {
-        // This might not measure anything if JIT figures it out that the registry is
-        // always noop
         Observation observation = Observation.createNotStarted("test.obs", noopRegistry)
             .lowCardinalityKeyValue("abc", "123")
             .start();
+        try (Observation.Scope ignored = observation.openScope()) {
+            observation.error(error);
+        }
         observation.stop();
 
         return observation;

docs/src/test/java/io/micrometer/docs/observation/ObservationConfiguringTests.java

@@ -76,10 +76,9 @@ void observation_config_customization() {
             .observationHandler(new DefaultMeterObservationHandler(meterRegistry));
 
         // Observation will be ignored because of the name
-        then(Observation.start("to.ignore", () -> new MyContext("don't ignore"), registry)).isSameAs(Observation.NOOP);
+        then(Observation.start("to.ignore", () -> new MyContext("don't ignore"), registry).isNoop()).isTrue();
         // Observation will be ignored because of the entries in MyContext
-        then(Observation.start("not.to.ignore", () -> new MyContext("user to ignore"), registry))
-            .isSameAs(Observation.NOOP);
+        then(Observation.start("not.to.ignore", () -> new MyContext("user to ignore"), registry).isNoop()).isTrue();
 
         // Observation will not be ignored...
         MyContext myContext = new MyContext("user not to ignore");

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2025 VMware, Inc.
+ *
+ * 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 io.micrometer.observation;
+
+/**
+ * No-op implementation of {@link Observation} except scope opening so that we can disable
+ * the instrumentation for certain Observations but keep context-propagation working.
+ *
+ * @author Jonatan Ivanov
+ * @author Tommy Ludwig
+ * @author Marcin Grzejszczak
+ */
+final class NoopButScopeHandlingObservation extends NoopObservation {
+
+    static final Observation INSTANCE = new NoopButScopeHandlingObservation();
+
+    @Override
+    public Scope openScope() {
+        return new SimpleObservation.SimpleScope(NoopObservationRegistry.FOR_SCOPES, this);
+    }
+
+}

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

@@ -20,14 +20,15 @@
 
 /**
  * No-op implementation of {@link Observation} so that we can disable the instrumentation
- * logic.
+ * logic entirely.
  *
  * @author Jonatan Ivanov
  * @author Tommy Ludwig
  * @author Marcin Grzejszczak
- * @since 1.10.0
  */
-final class NoopObservation implements Observation {
+class NoopObservation implements Observation {
+
+    static final Observation INSTANCE = new NoopObservation();
 
     private static final Context CONTEXT = new Context();
 
@@ -92,7 +93,7 @@ public void stop() {
 
     @Override
     public Scope openScope() {
-        return new SimpleObservation.SimpleScope(NoopObservationRegistry.FOR_SCOPES, this);
+        return NoopScope.INSTANCE;
     }
 
     /**
@@ -111,7 +112,7 @@ private NoopScope() {
 
         @Override
         public Observation getCurrentObservation() {
-            return Observation.NOOP;
+            return NoopObservation.INSTANCE;
         }
 
         @Override

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

@@ -50,9 +50,10 @@
 public interface Observation extends ObservationView {
 
     /**
-     * No-op observation.
+     * No-op observation. Do not use it to check if an Observation is no-op, use
+     * {@code observation.isNoop()} instead.
      */
-    Observation NOOP = new NoopObservation();
+    Observation NOOP = NoopObservation.INSTANCE;
 
     /**
      * Create and start an {@link Observation} with the given name. All Observations of
@@ -122,12 +123,12 @@ static Observation createNotStarted(String name, @Nullable ObservationRegistry r
     static <T extends Context> Observation createNotStarted(String name, Supplier<T> contextSupplier,
             @Nullable ObservationRegistry registry) {
         if (registry == null || registry.isNoop()) {
-            return NOOP;
+            return NoopObservation.INSTANCE;
         }
         Context context = contextSupplier.get();
         context.setParentFromCurrentObservation(registry);
         if (!registry.observationConfig().isObservationEnabled(name, context)) {
-            return NOOP;
+            return NoopButScopeHandlingObservation.INSTANCE;
         }
         return new SimpleObservation(name, registry, context);
     }
@@ -165,7 +166,7 @@ static <T extends Context> Observation createNotStarted(@Nullable ObservationCon
             ObservationConvention<T> defaultConvention, Supplier<T> contextSupplier,
             @Nullable ObservationRegistry registry) {
         if (registry == null || registry.isNoop()) {
-            return Observation.NOOP;
+            return NoopObservation.INSTANCE;
         }
         ObservationConvention<T> convention;
         T context = contextSupplier.get();
@@ -177,7 +178,7 @@ static <T extends Context> Observation createNotStarted(@Nullable ObservationCon
             convention = registry.observationConfig().getObservationConvention(context, defaultConvention);
         }
         if (!registry.observationConfig().isObservationEnabled(convention.getName(), context)) {
-            return NOOP;
+            return NoopButScopeHandlingObservation.INSTANCE;
         }
         return new SimpleObservation(convention, registry, context);
     }
@@ -309,13 +310,13 @@ static Observation createNotStarted(ObservationConvention<Context> observationCo
      */
     static <T extends Context> Observation createNotStarted(ObservationConvention<T> observationConvention,
             Supplier<T> contextSupplier, ObservationRegistry registry) {
-        if (registry == null || registry.isNoop() || observationConvention == NoopObservationConvention.INSTANCE) {
-            return NOOP;
+        if (registry == null || registry.isNoop()) {
+            return NoopObservation.INSTANCE;
         }
         T context = contextSupplier.get();
         context.setParentFromCurrentObservation(registry);
         if (!registry.observationConfig().isObservationEnabled(observationConvention.getName(), context)) {
-            return NOOP;
+            return NoopButScopeHandlingObservation.INSTANCE;
         }
         return new SimpleObservation(observationConvention, registry, context);
     }
@@ -416,7 +417,7 @@ default Observation highCardinalityKeyValues(KeyValues keyValues) {
      * @return {@code true} when this is a no-op observation
      */
     default boolean isNoop() {
-        return this == NOOP;
+        return this == NoopObservation.INSTANCE || this == NoopButScopeHandlingObservation.INSTANCE;
     }
 
     /**
@@ -622,7 +623,7 @@ default <T, E extends Throwable> CheckedCallable<T, E> wrapChecked(CheckedCallab
      * <li>Stops the {@code Observation}</li>
      * </ul>
      *
-     * NOTE: When the {@link ObservationRegistry} is a noop, this function receives a
+     * NOTE: When the {@link ObservationRegistry} is a no-op, this function receives a
      * default {@link Context} instance which is not the one that has been passed at
      * {@link Observation} creation.
      * @param function the {@link Function} to call
@@ -663,7 +664,7 @@ default <T, E extends Throwable> CheckedCallable<T, E> wrapChecked(CheckedCallab
      * <li>Stops the {@code Observation}</li>
      * </ul>
      *
-     * NOTE: When the {@link ObservationRegistry} is a noop, this function receives a
+     * NOTE: When the {@link ObservationRegistry} is a no-op, this function receives a
      * default {@link Context} instance which is not the one that has been passed at
      * {@link Observation} creation.
      * @param function the {@link CheckedFunction} to call

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

@@ -19,7 +19,7 @@
 
 /**
  * A predicate to define whether {@link Observation observation} should be created or a
- * {@link NoopObservation} instead.
+ * no-op Observation instead.
  *
  * @author Jonatan Ivanov
  * @author Tommy Ludwig

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

@@ -112,7 +112,7 @@ public ObservationConfig observationHandler(ObservationHandler<?> handler) {
 
         /**
          * Register a predicate to define whether {@link Observation observation} should
-         * be created or a {@link NoopObservation} instead.
+         * be created or a no-op Observation instead.
          * @param predicate predicate
          * @return This configuration instance
          */
@@ -167,8 +167,8 @@ <T extends Observation.Context> ObservationConvention<T> getObservationConventio
         }
 
         /**
-         * Check to assert whether {@link Observation} should be created or
-         * {@link NoopObservation} instead.
+         * Check to assert whether {@link Observation} should be created or a no-op
+         * Observation instead.
          * @param name observation technical name
          * @param context context
          * @return {@code true} when observation is enabled

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

@@ -23,12 +23,15 @@ class NoopObservationRegistryTests {
 
     @Test
     @SuppressWarnings("NullAway")
-    void should_respect_scopes() {
-        ObservationRegistry observationRegistry = ObservationRegistry.NOOP;
+    void shouldRespectScopesIfDisabledByPredicate() {
+        ObservationRegistry observationRegistry = ObservationRegistry.create();
+        observationRegistry.observationConfig().getObservationHandlers().add(new ObservationTextPublisher());
+        observationRegistry.observationConfig().observationPredicate((name, context) -> false);
         then(observationRegistry.getCurrentObservation()).isNull();
 
         Observation observation = Observation.start("foo", observationRegistry);
         then(observation.isNoop()).isTrue();
+        then(observation).isSameAs(NoopButScopeHandlingObservation.INSTANCE);
         then(observationRegistry.getCurrentObservation()).isNull();
 
         try (Observation.Scope scope = observation.openScope()) {
@@ -45,4 +48,60 @@ void should_respect_scopes() {
         then(observationRegistry.getCurrentObservation()).isNull();
     }
 
+    @Test
+    @SuppressWarnings("NullAway")
+    void shouldNotRespectScopesIfNullRegistryIsUsed() {
+        Observation observation = Observation.start("foo", null);
+        then(observation.isNoop()).isTrue();
+        then(observation).isSameAs(NoopObservation.INSTANCE);
+    }
+
+    @Test
+    @SuppressWarnings("NullAway")
+    void shouldNotRespectScopesIfNoopRegistryIsUsed() {
+        ObservationRegistry observationRegistry = ObservationRegistry.NOOP;
+        then(observationRegistry.getCurrentObservation()).isNull();
+
+        Observation observation = Observation.start("foo", observationRegistry);
+        then(observation.isNoop()).isTrue();
+        then(observation).isSameAs(NoopObservation.INSTANCE);
+        then(observationRegistry.getCurrentObservation()).isNull();
+
+        try (Observation.Scope ignored = observation.openScope()) {
+            then(observationRegistry.getCurrentObservationScope()).isSameAs(Observation.Scope.NOOP);
+            then(observationRegistry.getCurrentObservation()).isNull();
+            try (Observation.Scope ignored2 = observation.openScope()) {
+                then(observationRegistry.getCurrentObservationScope()).isSameAs(Observation.Scope.NOOP);
+                then(observationRegistry.getCurrentObservation()).isNull();
+            }
+            then(observationRegistry.getCurrentObservation()).isNull();
+        }
+
+        then(observationRegistry.getCurrentObservation()).isNull();
+    }
+
+    @Test
+    @SuppressWarnings("NullAway")
+    void shouldNotRespectScopesIfNoHandlersAreRegistered() {
+        ObservationRegistry observationRegistry = ObservationRegistry.create();
+        then(observationRegistry.getCurrentObservation()).isNull();
+
+        Observation observation = Observation.start("foo", observationRegistry);
+        then(observation.isNoop()).isTrue();
+        then(observation).isSameAs(NoopObservation.INSTANCE);
+        then(observationRegistry.getCurrentObservation()).isNull();
+
+        try (Observation.Scope ignored = observation.openScope()) {
+            then(observationRegistry.getCurrentObservationScope()).isSameAs(Observation.Scope.NOOP);
+            then(observationRegistry.getCurrentObservation()).isNull();
+            try (Observation.Scope ignored2 = observation.openScope()) {
+                then(observationRegistry.getCurrentObservationScope()).isSameAs(Observation.Scope.NOOP);
+                then(observationRegistry.getCurrentObservation()).isNull();
+            }
+            then(observationRegistry.getCurrentObservation()).isNull();
+        }
+
+        then(observationRegistry.getCurrentObservation()).isNull();
+    }
+
 }