Revert "rename AsyncOperationEndXX to AsyncEndXX, rename AttributeForReturnValue to AttributeReturnValue"

This reverts commit aaf4b3a.

Author: Duncan-tree-zhou

instrumentation-annotations-incubator/src/main/java/io/opentelemetry/instrumentation/annotations/incubator/AttributeReturnValue.java renamed to instrumentation-annotations-incubator/src/main/java/io/opentelemetry/instrumentation/annotations/incubator/AttributeForReturnValue.java

@@ -29,7 +29,7 @@
  */
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
-public @interface AttributeReturnValue {
+public @interface AttributeForReturnValue {
 
   /**
    * Attribute name for the return value.

instrumentation-annotations-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/async/AsyncEndStrategies.java

@@ -9,7 +9,7 @@
 import javax.annotation.Nullable;
 
 /** Callback that is called when async computation completes. */
-public interface AsyncEndHandler<REQUEST, RESPONSE> {
+public interface AsyncOperationEndHandler<REQUEST, RESPONSE> {
   void handle(
       Context context, REQUEST request, @Nullable RESPONSE response, @Nullable Throwable error);
 }

instrumentation-annotations-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/async/AsyncEndSupport.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.api.annotation.support.async;
+
+import javax.annotation.Nullable;
+
+/** A global registry of {@link AsyncOperationEndStrategy} implementations. */
+public abstract class AsyncOperationEndStrategies {
+  private static volatile AsyncOperationEndStrategies instance;
+
+  /**
+   * Sets the actual strategies' registry implementation. The javaagent uses weak references to make
+   * unloading strategy classes possible.
+   *
+   * <p>This is supposed to be only called by the javaagent. <b>Instrumentation must not call
+   * this.</b>
+   */
+  public static void internalSetStrategiesStorage(AsyncOperationEndStrategies strategies) {
+    instance = strategies;
+  }
+
+  /** Obtain instance of the async strategy registry. */
+  public static AsyncOperationEndStrategies instance() {
+    if (instance == null) {
+      instance = new AsyncOperationEndStrategiesImpl();
+    }
+    return instance;
+  }
+
+  /** Add the passed {@code strategy} to the registry. */
+  public abstract void registerStrategy(AsyncOperationEndStrategy strategy);
+
+  /** Remove the passed {@code strategy} from the registry. */
+  public abstract void unregisterStrategy(AsyncOperationEndStrategy strategy);
+
+  /**
+   * Returns an {@link AsyncOperationEndStrategy} that is able to compose over {@code returnType},
+   * or {@code null} if passed type is not supported by any of the strategies stored in this
+   * registry.
+   */
+  @Nullable
+  public abstract AsyncOperationEndStrategy resolveStrategy(Class<?> returnType);
+}

instrumentation-annotations-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/async/AsyncEndHandler.java renamed to instrumentation-annotations-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/async/AsyncOperationEndHandler.java

@@ -12,27 +12,27 @@
 import javax.annotation.Nullable;
 
 /** Default strategies' registry implementation that uses strong references. */
-final class AsyncEndStrategiesImpl extends AsyncEndStrategies {
-  private final List<AsyncEndStrategy> strategies = new CopyOnWriteArrayList<>();
+final class AsyncOperationEndStrategiesImpl extends AsyncOperationEndStrategies {
+  private final List<AsyncOperationEndStrategy> strategies = new CopyOnWriteArrayList<>();
 
-  AsyncEndStrategiesImpl() {
-    registerStrategy(Jdk8AsyncEndStrategy.INSTANCE);
+  AsyncOperationEndStrategiesImpl() {
+    registerStrategy(Jdk8AsyncOperationEndStrategy.INSTANCE);
   }
 
   @Override
-  public void registerStrategy(AsyncEndStrategy strategy) {
+  public void registerStrategy(AsyncOperationEndStrategy strategy) {
     strategies.add(requireNonNull(strategy));
   }
 
   @Override
-  public void unregisterStrategy(AsyncEndStrategy strategy) {
+  public void unregisterStrategy(AsyncOperationEndStrategy strategy) {
     strategies.remove(strategy);
   }
 
   @Nullable
   @Override
-  public AsyncEndStrategy resolveStrategy(Class<?> returnType) {
-    for (AsyncEndStrategy strategy : strategies) {
+  public AsyncOperationEndStrategy resolveStrategy(Class<?> returnType) {
+    for (AsyncOperationEndStrategy strategy : strategies) {
       if (strategy.supports(returnType)) {
         return strategy;
       }

instrumentation-annotations-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/async/AsyncOperationEndStrategies.java

@@ -12,9 +12,9 @@
  * Implementations of this interface describe how to compose over {@linkplain #supports(Class)
  * supported} asynchronous computation types and delay marking the operation as ended by calling
  * {@link Instrumenter#end(Context, Object, Object, Throwable)} or {@link
- * AsyncEndHandler#handle(Context, Object, Object, Throwable)}.
+ * AsyncOperationEndHandler#handle(Context, Object, Object, Throwable)}.
  */
-public interface AsyncEndStrategy {
+public interface AsyncOperationEndStrategy {
 
   /**
    * Returns true for every asynchronous computation type {@code asyncType} this strategy supports.
@@ -47,12 +47,12 @@ default <REQUEST, RESPONSE> Object end(
   }
 
   /**
-   * Composes over {@code asyncValue} and delays the {@link AsyncEndHandler#handle(Context, Object,
-   * Object, Throwable)} call until after the asynchronous operation represented by {@code
+   * Composes over {@code asyncValue} and delays the {@link AsyncOperationEndHandler#handle(Context,
+   * Object, Object, Throwable)} call until after the asynchronous operation represented by {@code
    * asyncValue} completes.
    *
-   * @param handler The {@link AsyncEndHandler} to be used to end the operation stored in the {@code
-   *     context}.
+   * @param handler The {@link AsyncOperationEndHandler} to be used to end the operation stored in
+   *     the {@code context}.
    * @param asyncValue Return value from the instrumented method. Must be an instance of a {@code
    *     asyncType} for which {@link #supports(Class)} returned true (in particular it must not be
    *     {@code null}).
@@ -63,7 +63,7 @@ default <REQUEST, RESPONSE> Object end(
    *     of completion.
    */
   <REQUEST, RESPONSE> Object end(
-      AsyncEndHandler<REQUEST, RESPONSE> handler,
+      AsyncOperationEndHandler<REQUEST, RESPONSE> handler,
       Context context,
       REQUEST request,
       Object asyncValue,