semconv stable code

instrumentation-annotations-support-testing/src/main/java/io/opentelemetry/javaagent/instrumentation/otelannotations/AbstractWithSpanTest.java

@@ -6,20 +6,20 @@
 package io.opentelemetry.javaagent.instrumentation.otelannotations;
 
 import static io.opentelemetry.api.common.AttributeKey.booleanKey;
+import static io.opentelemetry.instrumentation.testing.junit.code.SemconvCodeStabilityUtil.codeFunctionAssertions;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
-import static io.opentelemetry.semconv.incubating.CodeIncubatingAttributes.CODE_FUNCTION;
-import static io.opentelemetry.semconv.incubating.CodeIncubatingAttributes.CODE_NAMESPACE;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.catchThrowable;
 
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
 import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
+import io.opentelemetry.sdk.testing.assertj.AttributeAssertion;
 import io.opentelemetry.sdk.trace.data.StatusData;
+import java.util.List;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
-@SuppressWarnings("deprecation") // CodeIncubatingAttributes.CODE_FUNCTION is deprecated
 public abstract class AbstractWithSpanTest<T extends U, U> {
 
   @RegisterExtension
@@ -59,8 +59,7 @@ void success() {
                         .hasKind(SpanKind.INTERNAL)
                         .hasNoParent()
                         .hasAttributesSatisfyingExactly(
-                            equalTo(CODE_NAMESPACE, traced.getClass().getName()),
-                            equalTo(CODE_FUNCTION, "completable"))));
+                            codeFunctionAssertions(traced.getClass(), "completable"))));
   }
 
   @Test
@@ -82,8 +81,7 @@ void failure() {
                         .hasStatus(StatusData.error())
                         .hasException(AbstractTraced.FAILURE)
                         .hasAttributesSatisfyingExactly(
-                            equalTo(CODE_NAMESPACE, traced.getClass().getName()),
-                            equalTo(CODE_FUNCTION, "completable"))));
+                            codeFunctionAssertions(traced.getClass(), "completable"))));
   }
 
   @Test
@@ -92,17 +90,18 @@ void canceled() {
     T future = traced.completable();
     cancel(future);
 
+    List<AttributeAssertion> attributeAssertions =
+        codeFunctionAssertions(traced.getClass(), "completable");
+    attributeAssertions.add(equalTo(booleanKey(canceledKey()), true));
+
     testing.waitAndAssertTraces(
         trace ->
             trace.hasSpansSatisfyingExactly(
                 span ->
                     span.hasName("Traced.completable")
                         .hasKind(SpanKind.INTERNAL)
                         .hasNoParent()
-                        .hasAttributesSatisfyingExactly(
-                            equalTo(CODE_NAMESPACE, traced.getClass().getName()),
-                            equalTo(CODE_FUNCTION, "completable"),
-                            equalTo(booleanKey(canceledKey()), true))));
+                        .hasAttributesSatisfyingExactly(attributeAssertions)));
   }
 
   @Test
@@ -118,8 +117,7 @@ void immediateSuccess() {
                         .hasKind(SpanKind.INTERNAL)
                         .hasNoParent()
                         .hasAttributesSatisfyingExactly(
-                            equalTo(CODE_NAMESPACE, traced.getClass().getName()),
-                            equalTo(CODE_FUNCTION, "alreadySucceeded"))));
+                            codeFunctionAssertions(traced.getClass(), "alreadySucceeded"))));
   }
 
   @Test
@@ -138,7 +136,6 @@ void immediateFailure() {
                         .hasStatus(StatusData.error())
                         .hasException(AbstractTraced.FAILURE)
                         .hasAttributesSatisfyingExactly(
-                            equalTo(CODE_NAMESPACE, traced.getClass().getName()),
-                            equalTo(CODE_FUNCTION, "alreadyFailed"))));
+                            codeFunctionAssertions(traced.getClass(), "alreadyFailed"))));
   }
 }

instrumentation-api-incubator/build.gradle.kts

@@ -42,11 +42,11 @@ tasks {
   }
 
   val testStableSemconv by registering(Test::class) {
-    jvmArgs("-Dotel.semconv-stability.opt-in=database")
+    jvmArgs("-Dotel.semconv-stability.opt-in=database,code")
   }
 
   val testBothSemconv by registering(Test::class) {
-    jvmArgs("-Dotel.semconv-stability.opt-in=database/dup")
+    jvmArgs("-Dotel.semconv-stability.opt-in=database/dup,code/dup")
   }
 
   check {

instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/code/CodeAttributesExtractor.java

@@ -11,6 +11,8 @@
 import io.opentelemetry.api.common.AttributesBuilder;
 import io.opentelemetry.context.Context;
 import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor;
+import io.opentelemetry.instrumentation.api.internal.SemconvStability;
+import io.opentelemetry.semconv.CodeAttributes;
 import javax.annotation.Nullable;
 
 /**
@@ -22,9 +24,9 @@ public final class CodeAttributesExtractor<REQUEST, RESPONSE>
     implements AttributesExtractor<REQUEST, RESPONSE> {
 
   // copied from CodeIncubatingAttributes
-  private static final AttributeKey<String> CODE_FUNCTION = AttributeKey.stringKey("code.function");
   private static final AttributeKey<String> CODE_NAMESPACE =
       AttributeKey.stringKey("code.namespace");
+  private static final AttributeKey<String> CODE_FUNCTION = AttributeKey.stringKey("code.function");
 
   /** Creates the code attributes extractor. */
   public static <REQUEST, RESPONSE> AttributesExtractor<REQUEST, RESPONSE> create(
@@ -40,11 +42,28 @@ private CodeAttributesExtractor(CodeAttributesGetter<REQUEST> getter) {
 
   @Override
   public void onStart(AttributesBuilder attributes, Context parentContext, REQUEST request) {
+    StringBuilder sb = new StringBuilder();
     Class<?> cls = getter.getCodeClass(request);
     if (cls != null) {
-      internalSet(attributes, CODE_NAMESPACE, cls.getName());
+      sb.append(cls.getName());
+
+      if (SemconvStability.isEmitOldCodeSemconv()) {
+        internalSet(attributes, CODE_NAMESPACE, cls.getName());
+      }
+    }
+    String methodName = getter.getMethodName(request);
+    if (methodName != null) {
+      if (sb.length() > 0) {
+        sb.append(".");
+      }
+      sb.append(methodName);
+      if (SemconvStability.isEmitOldCodeSemconv()) {
+        internalSet(attributes, CODE_FUNCTION, methodName);
+      }
+    }
+    if (SemconvStability.isEmitStableCodeSemconv() && sb.length() > 0) {
+      internalSet(attributes, CodeAttributes.CODE_FUNCTION_NAME, sb.toString());
     }
-    internalSet(attributes, CODE_FUNCTION, getter.getMethodName(request));
   }
 
   @Override

instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/code/CodeAttributesExtractorTest.java

@@ -6,12 +6,14 @@
 package io.opentelemetry.instrumentation.api.incubator.semconv.code;
 
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
-import static org.assertj.core.api.Assertions.entry;
 
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.common.AttributesBuilder;
 import io.opentelemetry.context.Context;
 import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor;
+import io.opentelemetry.instrumentation.api.internal.SemconvStability;
+import io.opentelemetry.instrumentation.testing.junit.code.SemconvCodeStabilityUtil;
+import io.opentelemetry.semconv.CodeAttributes;
 import io.opentelemetry.semconv.incubating.CodeIncubatingAttributes;
 import java.util.Collections;
 import java.util.HashMap;
@@ -58,11 +60,19 @@ void shouldExtractAllAttributes() {
     underTest.onEnd(endAttributes, context, request, null, null);
 
     // then
-    assertThat(startAttributes.build())
-        .containsOnly(
-            entry(CodeIncubatingAttributes.CODE_NAMESPACE, TestClass.class.getName()),
-            entry(CodeIncubatingAttributes.CODE_FUNCTION, "doSomething"));
+    Attributes attributes = startAttributes.build();
+    SemconvCodeStabilityUtil.codeFunctionAssertions(TestClass.class, "doSomething");
 
+    if (SemconvStability.isEmitStableCodeSemconv()) {
+      assertThat(attributes)
+          .containsEntry(
+              CodeAttributes.CODE_FUNCTION_NAME, TestClass.class.getName() + ".doSomething");
+    }
+    if (SemconvStability.isEmitOldCodeSemconv()) {
+      assertThat(attributes)
+          .containsEntry(CodeIncubatingAttributes.CODE_NAMESPACE, TestClass.class.getName())
+          .containsEntry(CodeIncubatingAttributes.CODE_FUNCTION, "doSomething");
+    }
     assertThat(endAttributes.build().isEmpty()).isTrue();
   }
 

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/internal/SemconvStability.java

@@ -21,27 +21,47 @@ public final class SemconvStability {
   private static final boolean emitOldDatabaseSemconv;
   private static final boolean emitStableDatabaseSemconv;
 
+  private static final boolean emitOldCodeSemconv;
+  private static final boolean emitStableCodeSemconv;
+
   static {
     boolean oldDatabase = true;
     boolean stableDatabase = false;
 
+    boolean oldCode = true;
+    boolean stableCode = false;
+
     String value = ConfigPropertiesUtil.getString("otel.semconv-stability.opt-in");
     if (value != null) {
       Set<String> values = new HashSet<>(asList(value.split(",")));
+
+      // no else -- technically it's possible to set "XXX,XXX/dup", in which case we
+      // should emit both sets of attributes for XXX
+
       if (values.contains("database")) {
         oldDatabase = false;
         stableDatabase = true;
       }
-      // no else -- technically it's possible to set "database,database/dup", in which case we
-      // should emit both sets of attributes
       if (values.contains("database/dup")) {
         oldDatabase = true;
         stableDatabase = true;
       }
+
+      if (values.contains("code")) {
+        oldCode = false;
+        stableCode = true;
+      }
+      if (values.contains("code/dup")) {
+        oldCode = true;
+        stableCode = true;
+      }
     }
 
     emitOldDatabaseSemconv = oldDatabase;
     emitStableDatabaseSemconv = stableDatabase;
+
+    emitOldCodeSemconv = oldCode;
+    emitStableCodeSemconv = stableCode;
   }
 
   public static boolean emitOldDatabaseSemconv() {
@@ -77,5 +97,13 @@ public static String stableDbSystemName(String oldDbSystem) {
     return dbSystemName != null ? dbSystemName : oldDbSystem;
   }
 
+  public static boolean isEmitOldCodeSemconv() {
+    return emitOldCodeSemconv;
+  }
+
+  public static boolean isEmitStableCodeSemconv() {
+    return emitStableCodeSemconv;
+  }
+
   private SemconvStability() {}
 }

instrumentation/elasticsearch/elasticsearch-transport-5.3/javaagent/build.gradle.kts

@@ -78,7 +78,7 @@ tasks {
   }
 
   val testStableSemconv by registering(Test::class) {
-    jvmArgs("-Dotel.semconv-stability.opt-in=database")
+    jvmArgs("-Dotel.semconv-stability.opt-in=database,code")
   }
 
   check {

instrumentation/elasticsearch/elasticsearch-transport-5.3/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/elasticsearch/transport/v5_3/springdata/Elasticsearch53SpringRepositoryTest.java

@@ -7,6 +7,7 @@
 
 import static io.opentelemetry.api.common.AttributeKey.longKey;
 import static io.opentelemetry.api.common.AttributeKey.stringKey;
+import static io.opentelemetry.instrumentation.testing.junit.code.SemconvCodeStabilityUtil.codeFunctionAssertions;
 import static io.opentelemetry.instrumentation.testing.junit.db.SemconvStabilityUtil.maybeStable;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
@@ -17,9 +18,10 @@
 import io.opentelemetry.instrumentation.testing.internal.AutoCleanupExtension;
 import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
 import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
-import io.opentelemetry.semconv.incubating.CodeIncubatingAttributes;
+import io.opentelemetry.sdk.testing.assertj.AttributeAssertion;
 import io.opentelemetry.semconv.incubating.DbIncubatingAttributes;
 import java.io.File;
+import java.util.List;
 import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
@@ -79,11 +81,7 @@ void emptyRepository() {
                     span.hasName("DocRepository.findAll")
                         .hasKind(SpanKind.INTERNAL)
                         .hasNoParent()
-                        .hasAttributesSatisfyingExactly(
-                            equalTo(
-                                CodeIncubatingAttributes.CODE_NAMESPACE,
-                                DocRepository.class.getName()),
-                            equalTo(CodeIncubatingAttributes.CODE_FUNCTION, "findAll")),
+                        .hasAttributesSatisfyingExactly(assertFunctionName("findAll")),
                 span ->
                     span.hasName("SearchAction")
                         .hasKind(SpanKind.CLIENT)
@@ -113,11 +111,7 @@ void crud() {
                     span.hasName("DocRepository.index")
                         .hasKind(SpanKind.INTERNAL)
                         .hasNoParent()
-                        .hasAttributesSatisfyingExactly(
-                            equalTo(
-                                CodeIncubatingAttributes.CODE_NAMESPACE,
-                                DocRepository.class.getName()),
-                            equalTo(CodeIncubatingAttributes.CODE_FUNCTION, "index")),
+                        .hasAttributesSatisfyingExactly(assertFunctionName("index")),
                 span ->
                     span.hasName("IndexAction")
                         .hasKind(SpanKind.CLIENT)
@@ -162,11 +156,7 @@ void crud() {
                     span.hasName("DocRepository.findById")
                         .hasKind(SpanKind.INTERNAL)
                         .hasNoParent()
-                        .hasAttributesSatisfyingExactly(
-                            equalTo(
-                                CodeIncubatingAttributes.CODE_NAMESPACE,
-                                DocRepository.class.getName()),
-                            equalTo(CodeIncubatingAttributes.CODE_FUNCTION, "findById")),
+                        .hasAttributesSatisfyingExactly(assertFunctionName("findById")),
                 span ->
                     span.hasName("GetAction")
                         .hasKind(SpanKind.CLIENT)
@@ -196,11 +186,7 @@ void crud() {
                     span.hasName("DocRepository.index")
                         .hasKind(SpanKind.INTERNAL)
                         .hasNoParent()
-                        .hasAttributesSatisfyingExactly(
-                            equalTo(
-                                CodeIncubatingAttributes.CODE_NAMESPACE,
-                                DocRepository.class.getName()),
-                            equalTo(CodeIncubatingAttributes.CODE_FUNCTION, "index")),
+                        .hasAttributesSatisfyingExactly(assertFunctionName("index")),
                 span ->
                     span.hasName("IndexAction")
                         .hasKind(SpanKind.CLIENT)
@@ -240,11 +226,7 @@ void crud() {
                     span.hasName("DocRepository.findById")
                         .hasKind(SpanKind.INTERNAL)
                         .hasNoParent()
-                        .hasAttributesSatisfyingExactly(
-                            equalTo(
-                                CodeIncubatingAttributes.CODE_NAMESPACE,
-                                DocRepository.class.getName()),
-                            equalTo(CodeIncubatingAttributes.CODE_FUNCTION, "findById")),
+                        .hasAttributesSatisfyingExactly(assertFunctionName("findById")),
                 span ->
                     span.hasName("GetAction")
                         .hasKind(SpanKind.CLIENT)
@@ -272,11 +254,7 @@ void crud() {
                     span.hasName("DocRepository.deleteById")
                         .hasKind(SpanKind.INTERNAL)
                         .hasNoParent()
-                        .hasAttributesSatisfyingExactly(
-                            equalTo(
-                                CodeIncubatingAttributes.CODE_NAMESPACE,
-                                DocRepository.class.getName()),
-                            equalTo(CodeIncubatingAttributes.CODE_FUNCTION, "deleteById")),
+                        .hasAttributesSatisfyingExactly(assertFunctionName("deleteById")),
                 span ->
                     span.hasName("DeleteAction")
                         .hasKind(SpanKind.CLIENT)
@@ -315,11 +293,7 @@ void crud() {
                     span.hasName("DocRepository.findAll")
                         .hasKind(SpanKind.INTERNAL)
                         .hasNoParent()
-                        .hasAttributesSatisfyingExactly(
-                            equalTo(
-                                CodeIncubatingAttributes.CODE_NAMESPACE,
-                                DocRepository.class.getName()),
-                            equalTo(CodeIncubatingAttributes.CODE_FUNCTION, "findAll")),
+                        .hasAttributesSatisfyingExactly(assertFunctionName("findAll")),
                 span ->
                     span.hasName("SearchAction")
                         .hasKind(SpanKind.CLIENT)
@@ -334,4 +308,8 @@ void crud() {
                             equalTo(stringKey("elasticsearch.request.indices"), "test-index"),
                             equalTo(stringKey("elasticsearch.request.search.types"), "doc"))));
   }
+
+  private static List<AttributeAssertion> assertFunctionName(String methodName) {
+    return codeFunctionAssertions(DocRepository.class, methodName);
+  }
 }