@@ -31,7 +31,6 @@
 
 import com.google.api.core.InternalApi;
 import com.google.common.collect.ImmutableList;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import org.jspecify.annotations.NullMarked;
@@ -45,6 +44,8 @@
 @NullMarked
 @InternalApi
 class CompositeTracer extends BaseApiTracer {
+  private static final Scope NO_OP_SCOPE = () -> {};
+
   private final List<ApiTracer> children;
 
   public CompositeTracer(List<ApiTracer> children) {
@@ -53,60 +54,155 @@ public CompositeTracer(List<ApiTracer> children) {
 
   @Override
   public Scope inScope() {
-    final List<Scope> childScopes = new ArrayList<>(children.size());
+    // Fast paths for 0 or 1 child tracer to avoid allocating an array or CompositeScope
+    if (children.isEmpty()) {
+      return NO_OP_SCOPE;
+    }
+    if (children.size() == 1) {
+      Scope scope = children.get(0).inScope();
+      return scope != null ? scope : NO_OP_SCOPE;
+    }
+
+    Scope[] childScopes = new Scope[children.size()];
+    int scopeCount = 0;
 
     try {
+      // Enter each child scope in forward order, tracking only non-null scopes
       for (ApiTracer child : children) {
-        childScopes.add(child.inScope());
+        Scope scope = child.inScope();
+        if (scope != null) {
+          childScopes[scopeCount++] = scope;
+        }
       }
-    } catch (RuntimeException e) {
-      for (int i = childScopes.size() - 1; i >= 0; i--) {
+      if (scopeCount == 0) {
+        return NO_OP_SCOPE;
+      }
+      if (scopeCount == 1) {
+        return childScopes[0];
+      }
+      return new CompositeScope(childScopes, scopeCount);
+    } catch (Throwable t) {
+      // Roll back already-opened child scopes in reverse (LIFO) order if any child fails
+      for (int i = scopeCount - 1; i >= 0; i--) {
         try {
-          childScopes.get(i).close();
-        } catch (RuntimeException suppressed) {
-          e.addSuppressed(suppressed);
+          childScopes[i].close();
+        } catch (Throwable suppressed) {
+          if (t != suppressed) {
+            t.addSuppressed(suppressed);
+          }
         }
       }
-      throw e;
+      throw throwException(t);
     }
+  }
 
-    return () -> {
-      RuntimeException exception = null;
-      for (int i = childScopes.size() - 1; i >= 0; i--) {
-        try {
-          childScopes.get(i).close();
-        } catch (RuntimeException e) {
-          if (exception == null) {
-            exception = e;
-          } else {
-            exception.addSuppressed(e);
+  /**
+   * An aggregate {@link Scope} that encapsulates and closes multiple child scopes in reverse order.
+   */
+  private static class CompositeScope implements Scope {
+    private final Scope[] scopes;
+    private final int count;
+
+    /**
+     * Constructs a {@code CompositeScope} managing the given array of active child scopes.
+     *
+     * @param scopes the array containing active child scopes
+     * @param count the number of valid scopes in the array
+     */
+    CompositeScope(Scope[] scopes, int count) {
+      this.scopes = scopes;
+      this.count = count;
+    }
+
+    /** Closes all managed child scopes in reverse order, suppressing secondary exceptions. */
+    @Override
+    public void close() {
+      Throwable firstException = null;
+      // Close child scopes in reverse (LIFO) order to mirror the order they were entered
+      for (int i = count - 1; i >= 0; i--) {
+        Scope scope = scopes[i];
+        if (scope != null) {
+          // Clear reference to make CompositeScope.close() idempotent
+          scopes[i] = null;
+          try {
+            scope.close();
+          } catch (Throwable t) {
+            // Capture the first failure and attach subsequent failures as suppressed exceptions
+            if (firstException == null) {
+              firstException = t;
+            } else if (firstException != t) {
+              firstException.addSuppressed(t);
+            }
           }
         }
       }
-      if (exception != null) {
-        throw exception;
+      if (firstException != null) {
+        throw throwException(firstException);
       }
-    };
+    }
+  }
+
+  /**
+   * Rethrows or wraps a {@link Throwable} without losing runtime exception or error fidelity.
+   *
+   * @param t the throwable to rethrow or wrap
+   * @return a {@link RuntimeException} wrapping {@code t} if {@code t} is a checked exception
+   */
+  private static RuntimeException throwException(Throwable t) {
+    if (t instanceof RuntimeException) {
+      return (RuntimeException) t;
+    }
+    if (t instanceof Error) {
+      throw (Error) t;
+    }
+    return new RuntimeException(t);
+  }
+
+  /**
+   * Enters the tracer's ambient scope safely, returning a no-op {@link Scope} if entering fails.
+   * This avoids allocating runnables, throwing exceptions, or returning null during lifecycle
+   * notifications.
+   *
+   * <p>Entering the ambient scope ensures active trace span context is present on the thread so
+   * that OpenTelemetry metric measurements recorded in lifecycle callbacks attach exemplars
+   * pointing to the active span.
+   */
+  private Scope enterScope() {
+    try {
+      return inScope();
+    } catch (RuntimeException e) {
+      // Ignore to prevent disrupting the lifecycle notification
+      return NO_OP_SCOPE;
+    }
   }
 
   @Override
   public void operationSucceeded() {
-    for (int i = children.size() - 1; i >= 0; i--) {
-      children.get(i).operationSucceeded();
+    // Activate ambient span context so child tracers (e.g. metrics) can sample trace exemplars
+    try (Scope s = enterScope()) {
+      for (int i = children.size() - 1; i >= 0; i--) {
+        children.get(i).operationSucceeded();
+      }
     }
   }
 
   @Override
   public void operationCancelled() {
-    for (int i = children.size() - 1; i >= 0; i--) {
-      children.get(i).operationCancelled();
+    // Activate ambient span context so child tracers (e.g. metrics) can sample trace exemplars
+    try (Scope s = enterScope()) {
+      for (int i = children.size() - 1; i >= 0; i--) {
+        children.get(i).operationCancelled();
+      }
     }
   }
 
   @Override
   public void operationFailed(Throwable error) {
-    for (int i = children.size() - 1; i >= 0; i--) {
-      children.get(i).operationFailed(error);
+    // Activate ambient span context so child tracers (e.g. metrics) can sample trace exemplars
+    try (Scope s = enterScope()) {
+      for (int i = children.size() - 1; i >= 0; i--) {
+        children.get(i).operationFailed(error);
+      }
     }
   }
 
@@ -134,43 +230,61 @@ public void attemptStarted(Object request, int attemptNumber) {
 
   @Override
   public void attemptSucceeded() {
-    for (int i = children.size() - 1; i >= 0; i--) {
-      children.get(i).attemptSucceeded();
+    // Activate ambient span context so child tracers (e.g. metrics) can sample trace exemplars
+    try (Scope s = enterScope()) {
+      for (int i = children.size() - 1; i >= 0; i--) {
+        children.get(i).attemptSucceeded();
+      }
     }
   }
 
   @Override
   public void attemptCancelled() {
-    for (int i = children.size() - 1; i >= 0; i--) {
-      children.get(i).attemptCancelled();
+    // Activate ambient span context so child tracers (e.g. metrics) can sample trace exemplars
+    try (Scope s = enterScope()) {
+      for (int i = children.size() - 1; i >= 0; i--) {
+        children.get(i).attemptCancelled();
+      }
     }
   }
 
   @Override
   public void attemptFailed(Throwable error, org.threeten.bp.Duration delay) {
-    for (int i = children.size() - 1; i >= 0; i--) {
-      children.get(i).attemptFailed(error, delay);
+    // Activate ambient span context so child tracers (e.g. metrics) can sample trace exemplars
+    try (Scope s = enterScope()) {
+      for (int i = children.size() - 1; i >= 0; i--) {
+        children.get(i).attemptFailed(error, delay);
+      }
     }
   }
 
   @Override
   public void attemptFailedDuration(Throwable error, java.time.Duration delay) {
-    for (int i = children.size() - 1; i >= 0; i--) {
-      children.get(i).attemptFailedDuration(error, delay);
+    // Activate ambient span context so child tracers (e.g. metrics) can sample trace exemplars
+    try (Scope s = enterScope()) {
+      for (int i = children.size() - 1; i >= 0; i--) {
+        children.get(i).attemptFailedDuration(error, delay);
+      }
     }
   }
 
   @Override
   public void attemptFailedRetriesExhausted(Throwable error) {
-    for (int i = children.size() - 1; i >= 0; i--) {
-      children.get(i).attemptFailedRetriesExhausted(error);
+    // Activate ambient span context so child tracers (e.g. metrics) can sample trace exemplars
+    try (Scope s = enterScope()) {
+      for (int i = children.size() - 1; i >= 0; i--) {
+        children.get(i).attemptFailedRetriesExhausted(error);
+      }
     }
   }
 
   @Override
   public void attemptPermanentFailure(Throwable error) {
-    for (int i = children.size() - 1; i >= 0; i--) {
-      children.get(i).attemptPermanentFailure(error);
+    // Activate ambient span context so child tracers (e.g. metrics) can sample trace exemplars
+    try (Scope s = enterScope()) {
+      for (int i = children.size() - 1; i >= 0; i--) {
+        children.get(i).attemptPermanentFailure(error);
+      }
     }
   }
 
 
@@ -35,6 +35,7 @@
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -125,6 +126,26 @@ void testInScope_childScopeCloseThrows() {
     inOrder.verify(scope1).close();
   }
 
+  @Test
+  void testInScope_compositeScopeClose_isIdempotent() {
+    ApiTracer.Scope scope1 =
+        mock(ApiTracer.Scope.class, Mockito.withSettings().withoutAnnotations());
+    ApiTracer.Scope scope2 =
+        mock(ApiTracer.Scope.class, Mockito.withSettings().withoutAnnotations());
+
+    when(child1.inScope()).thenReturn(scope1);
+    when(child2.inScope()).thenReturn(scope2);
+
+    ApiTracer.Scope compositeScope = compositeTracer.inScope();
+
+    compositeScope.close();
+    // Subsequent close should be idempotent and not invoke underlying scopes again
+    compositeScope.close();
+
+    verify(scope2, times(1)).close();
+    verify(scope1, times(1)).close();
+  }
+
   @Test
   void testOperationSucceeded() {
     compositeTracer.operationSucceeded();