Combine continuation implementations into one which supports multiple activations.

Call the `hold()` method on the continuation to let multiple threads activate it
concurrently and close their scopes without fear of prematurely closing the span.
You must then call `cancel()` at some point to avoid discarding traces.

Author: mcculls

dd-java-agent/agent-bootstrap/src/main/java/datadog/trace/bootstrap/instrumentation/java/concurrent/ConcurrentState.java

@@ -69,23 +69,23 @@ public static <K> void closeScope(
     if (throwable != null) {
       // This might lead to the continuation being consumed early, but it's better to be safe if we
       // threw an Exception on entry
-      state.closeContinuation();
+      state.cancelContinuation();
     }
   }
 
-  public static <K> void closeAndClearContinuation(
+  public static <K> void cancelAndClearContinuation(
       ContextStore<K, ConcurrentState> contextStore, K key) {
     final ConcurrentState state = contextStore.get(key);
     if (state == null) {
       return;
     }
-    state.closeAndClearContinuation();
+    state.cancelAndClearContinuation();
   }
 
   private boolean captureAndSetContinuation(final AgentScope scope) {
     if (CONTINUATION.compareAndSet(this, null, CLAIMED)) {
       // lazy write is guaranteed to be seen by getAndSet
-      CONTINUATION.lazySet(this, scope.captureConcurrent());
+      CONTINUATION.lazySet(this, scope.capture().hold());
       return true;
     }
     return false;
@@ -99,14 +99,14 @@ private AgentScope activateAndContinueContinuation() {
     return null;
   }
 
-  private void closeContinuation() {
+  private void cancelContinuation() {
     final AgentScope.Continuation continuation = CONTINUATION.get(this);
     if (continuation != null && continuation != CLAIMED) {
       continuation.cancel();
     }
   }
 
-  private void closeAndClearContinuation() {
+  private void cancelAndClearContinuation() {
     final AgentScope.Continuation continuation = CONTINUATION.get(this);
     if (continuation != null && continuation != CLAIMED) {
       // We should never be able to reuse this state

dd-java-agent/agent-bootstrap/src/main/java/datadog/trace/bootstrap/instrumentation/java/concurrent/ContinuationClaim.java

@@ -7,6 +7,11 @@ final class ContinuationClaim implements AgentScope.Continuation {
 
   public static final ContinuationClaim CLAIMED = new ContinuationClaim();
 
+  @Override
+  public AgentScope.Continuation hold() {
+    throw new IllegalStateException();
+  }
+
   @Override
   public AgentScope activate() {
     throw new IllegalStateException();

dd-java-agent/instrumentation/java-concurrent/java-completablefuture/src/main/java/java/util/concurrent/CompletableFutureAdvice.java

@@ -72,7 +72,7 @@ public static void exit(
       boolean claimed = !wasClaimed && !hadExecutor && zis.getForkJoinTaskTag() == 1;
       if (mode == ASYNC || (mode < ASYNC && claimed) || !zis.isLive()) {
         contextStore = InstrumentationContext.get(UniCompletion.class, ConcurrentState.class);
-        ConcurrentState.closeAndClearContinuation(contextStore, zis);
+        ConcurrentState.cancelAndClearContinuation(contextStore, zis);
       }
       if (scope != null || throwable != null) {
         if (contextStore == null) {

dd-java-agent/instrumentation/kotlin-coroutines/src/main/java/datadog/trace/instrumentation/kotlin/coroutines/ScopeStateCoroutineContext.java

@@ -121,7 +121,7 @@ public void maybeInitialize() {
       if (!isInitialized) {
         final AgentScope activeScope = AgentTracer.get().activeScope();
         if (activeScope != null && activeScope.isAsyncPropagating()) {
-          continuation = activeScope.captureConcurrent();
+          continuation = activeScope.capture().hold();
         }
         isInitialized = true;
       }

dd-java-agent/instrumentation/opentelemetry/opentelemetry-0.3/src/main/java/datadog/trace/instrumentation/opentelemetry/OtelScope.java

@@ -16,11 +16,6 @@ public Continuation capture() {
     return delegate.capture();
   }
 
-  @Override
-  public Continuation captureConcurrent() {
-    return delegate.captureConcurrent();
-  }
-
   @Override
   public void close() {
     delegate.close();

dd-java-agent/instrumentation/opentracing/api-0.31/src/main/java/datadog/trace/instrumentation/opentracing31/OTScopeManager.java

@@ -68,11 +68,6 @@ public Continuation capture() {
       return delegate.capture();
     }
 
-    @Override
-    public Continuation captureConcurrent() {
-      return delegate.captureConcurrent();
-    }
-
     public boolean isFinishSpanOnClose() {
       return finishSpanOnClose;
     }

dd-java-agent/instrumentation/opentracing/api-0.32/src/main/java/datadog/trace/instrumentation/opentracing32/OTScopeManager.java

@@ -78,11 +78,6 @@ public Continuation capture() {
       return delegate.capture();
     }
 
-    @Override
-    public Continuation captureConcurrent() {
-      return delegate.captureConcurrent();
-    }
-
     public boolean isFinishSpanOnClose() {
       return finishSpanOnClose;
     }

dd-trace-api/src/main/java/datadog/trace/context/NoopTraceScope.java

@@ -8,6 +8,11 @@ public static class NoopContinuation implements Continuation {
 
     private NoopContinuation() {}
 
+    @Override
+    public Continuation hold() {
+      return this;
+    }
+
     @Override
     public TraceScope activate() {
       return NoopTraceScope.INSTANCE;
@@ -24,11 +29,6 @@ public Continuation capture() {
     return NoopContinuation.INSTANCE;
   }
 
-  @Override
-  public Continuation captureConcurrent() {
-    return null;
-  }
-
   @Override
   public void close() {}
 }

dd-trace-api/src/main/java/datadog/trace/context/TraceScope.java

@@ -14,18 +14,11 @@ public interface TraceScope extends Closeable {
    */
   Continuation capture();
 
-  /**
-   * Prevent the trace attached to this TraceScope from reporting until the returned Continuation is
-   * either activated (and the returned scope is closed), or canceled.
-   *
-   * <p>Should be called on the parent thread.
-   *
-   * <p>If the returned {@link Continuation} is activated, it needs to be canceled in addition to
-   * the returned {@link TraceScope} being closed. This is to allow multiple concurrent threads that
-   * activate the continuation to race in a safe way, and close the scopes without fear of closing
-   * the related {@code Span} prematurely.
-   */
-  Continuation captureConcurrent();
+  /** @deprecated Replaced by {@code capture().hold()}. */
+  @Deprecated
+  default Continuation captureConcurrent() {
+    return capture().hold();
+  }
 
   /** Close the activated context and allow any underlying spans to finish. */
   @Override
@@ -61,6 +54,15 @@ default void setAsyncPropagation(boolean value) {
    */
   interface Continuation {
 
+    /**
+     * Prevent the trace attached to this scope from reporting until the continuation is explicitly
+     * cancelled. You must call {@link #cancel()} at some point to avoid discarding traces.
+     *
+     * <p>Use this when you want to let multiple threads activate the continuation concurrently and
+     * close their scopes without fear of prematurely closing the related span.
+     */
+    Continuation hold();
+
     /**
      * Activate the continuation.
      *