Update the OpenTelemetry SDK version to 1.47.0 (#13250)

Co-authored-by: Lauri Tulmin <ltulmin@splunk.com>

.fossa.yml

@@ -751,6 +751,9 @@ targets:
     - type: gradle
       path: ./
       target: ':instrumentation:opentelemetry-api:opentelemetry-api-1.42:javaagent'
+    - type: gradle
+      path: ./
+      target: ':instrumentation:opentelemetry-api:opentelemetry-api-1.47:javaagent'
     - type: gradle
       path: ./
       target: ':instrumentation:pekko:pekko-actor-1.0:javaagent'

.github/workflows/build-common.yml

@@ -68,7 +68,8 @@ jobs:
           cache-read-only: ${{ inputs.cache-read-only }}
 
       - name: Generate license report
-        run: ./gradlew generateLicenseReport ${{ inputs.no-build-cache && '--no-build-cache' || '' }}
+        # with the build cache enabled occasionally produces outdated results
+        run: ./gradlew generateLicenseReport --no-build-cache
 
       - name: Check licenses
         run: |

dependencyManagement/build.gradle.kts

@@ -5,7 +5,7 @@ plugins {
 data class DependencySet(val group: String, val version: String, val modules: List<String>)
 
 // this line is managed by .github/scripts/update-sdk-version.sh
-val otelSdkVersion = "1.46.0"
+val otelSdkVersion = "1.47.0"
 val otelContribVersion = "1.43.0-alpha"
 val otelSdkAlphaVersion = otelSdkVersion.replaceFirst("(-SNAPSHOT)?$".toRegex(), "-alpha$1")
 

examples/distro/build.gradle

@@ -27,7 +27,7 @@ subprojects {
   ext {
     versions = [
       // this line is managed by .github/scripts/update-sdk-version.sh
-      opentelemetrySdk           : "1.46.0",
+      opentelemetrySdk           : "1.47.0",
 
       // these lines are managed by .github/scripts/update-version.sh
       opentelemetryJavaagent     : "2.13.0-SNAPSHOT",

examples/extension/build.gradle

@@ -23,7 +23,7 @@ version '1.0'
 ext {
   versions = [
     // this line is managed by .github/scripts/update-sdk-version.sh
-    opentelemetrySdk           : "1.46.0",
+    opentelemetrySdk           : "1.47.0",
 
     // these lines are managed by .github/scripts/update-version.sh
     opentelemetryJavaagent     : "2.13.0-SNAPSHOT",

instrumentation/opentelemetry-api/opentelemetry-api-1.27/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_27/ApplicationOpenTelemetry127.java

@@ -120,11 +120,18 @@ public final class ApplicationOpenTelemetry127 implements OpenTelemetry {
   }
 
   private static ApplicationLoggerFactory getLoggerFactory() {
-    // this class is defined in opentelemetry-api-1.42
+    // this class is defined in opentelemetry-api-1.47
     ApplicationLoggerFactory loggerFactory =
         getLoggerFactory(
-            "io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_42.incubator.logs.ApplicationLoggerFactory142Incubator");
+            "io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator.logs.ApplicationLoggerFactory147Incubator");
     if (loggerFactory == null) {
+      // this class is defined in opentelemetry-api-1.42
+      loggerFactory =
+          getLoggerFactory(
+              "io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_42.incubator.logs.ApplicationLoggerFactory142Incubator");
+    }
+    if (loggerFactory == null) {
+      // this class is defined in opentelemetry-api-1.42
       loggerFactory =
           getLoggerFactory(
               "io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_42.logs.ApplicationLoggerFactory142");
@@ -147,10 +154,16 @@ public final class ApplicationOpenTelemetry127 implements OpenTelemetry {
   }
 
   private static ApplicationTracerFactory getTracerFactory() {
-    // this class is defined in opentelemetry-api-1.40
+    // this class is defined in opentelemetry-api-1.47
     ApplicationTracerFactory tracerFactory =
         getTracerFactory(
-            "io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_40.incubator.trace.ApplicationTracerFactory140Incubator");
+            "io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator.trace.ApplicationTracerFactory147Incubator");
+    if (tracerFactory == null) {
+      // this class is defined in opentelemetry-api-1.40
+      tracerFactory =
+          getTracerFactory(
+              "io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_40.incubator.trace.ApplicationTracerFactory140Incubator");
+    }
     if (tracerFactory == null) {
       tracerFactory = new ApplicationTracerFactory127();
     }

instrumentation/opentelemetry-api/opentelemetry-api-1.32/javaagent/build.gradle.kts

@@ -21,6 +21,9 @@ configurations.configureEach {
     resolutionStrategy {
       force("io.opentelemetry:opentelemetry-api:1.32.0")
     }
+    if (name.equals("testRuntimeClasspath")) {
+      exclude(group = "io.opentelemetry", module = "opentelemetry-api-incubator")
+    }
   }
 }
 

instrumentation/opentelemetry-api/opentelemetry-api-1.32/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_32/metrics/MeterTest.java

@@ -9,6 +9,7 @@ import static io.opentelemetry.api.common.AttributeKey.stringKey;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
 import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.metrics.DoubleHistogram;
@@ -44,6 +45,15 @@ class MeterTest {
             .build();
   }
 
+  @Test
+  void incubatingApiNotAvailable() {
+    assertThatThrownBy(
+            () ->
+                Class.forName(
+                    "io.opentelemetry.extension.incubator.metrics.ExtendedDoubleGaugeBuilder"))
+        .isInstanceOf(ClassNotFoundException.class);
+  }
+
   @Test
   void longHistogram() {
     LongHistogramBuilder builder =

instrumentation/opentelemetry-api/opentelemetry-api-1.37/javaagent/build.gradle.kts

@@ -21,16 +21,15 @@ configurations.configureEach {
       force("io.opentelemetry:opentelemetry-api:1.37.0")
       force("io.opentelemetry:opentelemetry-api-incubator:1.37.0-alpha")
     }
-    if (name.startsWith("incubatorTest") || name.startsWith("noopTest")) {
+    if (name.startsWith("oldAndNewIncubatorTest")) {
-      resolutionStrategy {
-        force("io.opentelemetry:opentelemetry-api-incubator:1.37.0-alpha")
-      }
-    } else if (name.startsWith("oldAndNewIncubatorTest")) {
       resolutionStrategy {
         force("io.opentelemetry:opentelemetry-api-incubator:1.37.0-alpha")
         force("io.opentelemetry:opentelemetry-extension-incubator:1.32.0-alpha")
       }
     }
+    if (name.equals("testRuntimeClasspath")) {
+      exclude(group = "io.opentelemetry", module = "opentelemetry-api-incubator")
+    }
   }
 }
 

instrumentation/opentelemetry-api/opentelemetry-api-1.37/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_37/metrics/MeterTest.java

@@ -9,6 +9,7 @@ import static io.opentelemetry.api.common.AttributeKey.stringKey;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
 import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.metrics.DoubleHistogram;
@@ -44,6 +45,13 @@ class MeterTest {
             .build();
   }
 
+  @Test
+  void incubatingApiNotAvailable() {
+    assertThatThrownBy(
+            () -> Class.forName("io.opentelemetry.api.incubator.metrics.ExtendedLongGaugeBuilder"))
+        .isInstanceOf(ClassNotFoundException.class);
+  }
+
   @Test
   void longHistogram() {
     LongHistogramBuilder builder =

instrumentation/opentelemetry-api/opentelemetry-api-1.38/javaagent/build.gradle.kts

@@ -20,11 +20,10 @@ configurations.configureEach {
   if (name.endsWith("testRuntimeClasspath", true) || name.endsWith("testCompileClasspath", true)) {
     resolutionStrategy {
       force("io.opentelemetry:opentelemetry-api:1.38.0")
+      force("io.opentelemetry:opentelemetry-api-incubator:1.38.0-alpha")
     }
-    if (name.startsWith("incubatorTest") || name.startsWith("noopTest")) {
+    if (name.equals("testRuntimeClasspath")) {
-      resolutionStrategy {
+      exclude(group = "io.opentelemetry", module = "opentelemetry-api-incubator")
-        force("io.opentelemetry:opentelemetry-api-incubator:1.38.0-alpha")
-      }
     }
   }
 }

instrumentation/opentelemetry-api/opentelemetry-api-1.38/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_38/metrics/MeterTest.java

@@ -8,6 +8,7 @@ package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_38.metric
 import static io.opentelemetry.api.common.AttributeKey.stringKey;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.metrics.DoubleGauge;
@@ -44,6 +45,13 @@ class MeterTest {
             .build();
   }
 
+  @Test
+  void incubatingApiNotAvailable() {
+    assertThatThrownBy(
+            () -> Class.forName("io.opentelemetry.api.incubator.metrics.ExtendedLongGaugeBuilder"))
+        .isInstanceOf(ClassNotFoundException.class);
+  }
+
   @Test
   void syncLongGauge() throws InterruptedException {
     LongGaugeBuilder builder =

instrumentation/opentelemetry-api/opentelemetry-api-1.40/javaagent/build.gradle.kts

@@ -23,6 +23,7 @@ configurations.configureEach {
   if (name.endsWith("testRuntimeClasspath", true) || name.endsWith("testCompileClasspath", true)) {
     resolutionStrategy {
       force("io.opentelemetry:opentelemetry-api:1.40.0")
+      force("io.opentelemetry:opentelemetry-api-incubator:1.40.0-alpha")
     }
   }
 }

instrumentation/opentelemetry-api/opentelemetry-api-1.40/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_40/incubator/OpenTelemetryApiIncubatorInstrumentationModule.java

@@ -24,8 +24,11 @@ public class OpenTelemetryApiIncubatorInstrumentationModule extends Instrumentat
 
   @Override
   public ElementMatcher.Junction<ClassLoader> classLoaderMatcher() {
+    // EventLogger was removed in 1.47, including it here prevents the instrumentation from applying
+    // to 1.47
     return hasClassesNamed(
-        "application.io.opentelemetry.api.incubator.metrics.ExtendedDoubleHistogram");
+        "application.io.opentelemetry.api.incubator.metrics.ExtendedDoubleHistogram",
+        "application.io.opentelemetry.api.incubator.events.EventLogger");
   }
 
   @Override

instrumentation/opentelemetry-api/opentelemetry-api-1.40/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_40/incubator/trace/ApplicationSpanBuilder140Incubator.java

@@ -27,12 +27,12 @@ import java.util.concurrent.TimeUnit;
 import java.util.function.BiConsumer;
 import javax.annotation.Nullable;
 
-final class ApplicationSpanBuilder140Incubator extends ApplicationSpanBuilder
+public final class ApplicationSpanBuilder140Incubator extends ApplicationSpanBuilder
     implements ExtendedSpanBuilder {
 
   private final io.opentelemetry.api.incubator.trace.ExtendedSpanBuilder agentBuilder;
 
-  ApplicationSpanBuilder140Incubator(io.opentelemetry.api.trace.SpanBuilder agentBuilder) {
+  public ApplicationSpanBuilder140Incubator(io.opentelemetry.api.trace.SpanBuilder agentBuilder) {
     super(agentBuilder);
     this.agentBuilder = (io.opentelemetry.api.incubator.trace.ExtendedSpanBuilder) agentBuilder;
   }

instrumentation/opentelemetry-api/opentelemetry-api-1.42/javaagent/build.gradle.kts

@@ -22,11 +22,10 @@ configurations.configureEach {
   if (name.endsWith("testRuntimeClasspath", true) || name.endsWith("testCompileClasspath", true)) {
     resolutionStrategy {
       force("io.opentelemetry:opentelemetry-api:1.42.0")
+      force("io.opentelemetry:opentelemetry-api-incubator:1.42.0-alpha")
     }
-    if (name.startsWith("incubatorTest")) {
+    if (name.equals("testRuntimeClasspath")) {
-      resolutionStrategy {
+      exclude(group = "io.opentelemetry", module = "opentelemetry-api-incubator")
-        force("io.opentelemetry:opentelemetry-api-incubator:1.42.0-alpha")
-      }
     }
   }
 }

instrumentation/opentelemetry-api/opentelemetry-api-1.42/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_42/incubator/OpenTelemetryApiIncubatorInstrumentationModule.java

@@ -24,7 +24,11 @@ public class OpenTelemetryApiIncubatorInstrumentationModule extends Instrumentat
 
   @Override
   public ElementMatcher.Junction<ClassLoader> classLoaderMatcher() {
-    return hasClassesNamed("application.io.opentelemetry.api.incubator.logs.ExtendedLogger");
+    // EventLogger was removed in 1.47, including it here prevents the instrumentation from applying
+    // to 1.47
+    return hasClassesNamed(
+        "application.io.opentelemetry.api.incubator.logs.ExtendedLogger",
+        "application.io.opentelemetry.api.incubator.events.EventLogger");
   }
 
   @Override

instrumentation/opentelemetry-api/opentelemetry-api-1.42/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_42/incubator/logs/ApplicationLogRecordBuilder142.java

@@ -1,74 +0,0 @@
-/*
- * Copyright The OpenTelemetry Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_42.incubator.logs;
-
-import application.io.opentelemetry.api.common.KeyValue;
-import application.io.opentelemetry.api.common.Value;
-import application.io.opentelemetry.api.logs.LogRecordBuilder;
-import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_27.logs.ApplicationLogRecordBuilder;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.List;
-
-class ApplicationLogRecordBuilder142 extends ApplicationLogRecordBuilder
-    implements LogRecordBuilder {
-
-  private final io.opentelemetry.api.logs.LogRecordBuilder agentLogRecordBuilder;
-
-  ApplicationLogRecordBuilder142(io.opentelemetry.api.logs.LogRecordBuilder agentLogRecordBuilder) {
-    super(agentLogRecordBuilder);
-    this.agentLogRecordBuilder = agentLogRecordBuilder;
-  }
-
-  @Override
-  public LogRecordBuilder setBody(Value<?> body) {
-    agentLogRecordBuilder.setBody(convertValue(body));
-    return this;
-  }
-
-  @SuppressWarnings("unchecked")
-  private static io.opentelemetry.api.common.Value<?> convertValue(Value<?> value) {
-    if (value == null) {
-      return null;
-    }
-
-    switch (value.getType()) {
-      case STRING:
-        return io.opentelemetry.api.common.Value.of((String) value.getValue());
-      case BOOLEAN:
-        return io.opentelemetry.api.common.Value.of((Boolean) value.getValue());
-      case LONG:
-        return io.opentelemetry.api.common.Value.of((Long) value.getValue());
-      case DOUBLE:
-        return io.opentelemetry.api.common.Value.of((Double) value.getValue());
-      case ARRAY:
-        List<Value<?>> values = (List<Value<?>>) value.getValue();
-        List<io.opentelemetry.api.common.Value<?>> convertedValues = new ArrayList<>();
-        for (Value<?> source : values) {
-          convertedValues.add(convertValue(source));
-        }
-        return io.opentelemetry.api.common.Value.of(convertedValues);
-      case KEY_VALUE_LIST:
-        List<KeyValue> keyValueList = (List<KeyValue>) value.getValue();
-        io.opentelemetry.api.common.KeyValue[] convertedKeyValueList =
-            new io.opentelemetry.api.common.KeyValue[keyValueList.size()];
-        int i = 0;
-        for (KeyValue source : keyValueList) {
-          convertedKeyValueList[i++] =
-              io.opentelemetry.api.common.KeyValue.of(
-                  source.getKey(), convertValue(source.getValue()));
-        }
-        return io.opentelemetry.api.common.Value.of(convertedKeyValueList);
-      case BYTES:
-        ByteBuffer byteBuffer = (ByteBuffer) value.getValue();
-        byte[] bytes = new byte[byteBuffer.remaining()];
-        byteBuffer.get(bytes);
-        break;
-    }
-
-    throw new IllegalStateException("Unhandled value type: " + value.getType());
-  }
-}

instrumentation/opentelemetry-api/opentelemetry-api-1.42/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_42/incubator/logs/ApplicationLogger142Incubator.java

@@ -7,6 +7,7 @@ package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_42.incuba
 
 import application.io.opentelemetry.api.logs.LogRecordBuilder;
 import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_40.incubator.logs.ApplicationLogger140Incubator;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_42.logs.ApplicationLogRecordBuilder142;
 
 class ApplicationLogger142Incubator extends ApplicationLogger140Incubator {
 

instrumentation/opentelemetry-api/opentelemetry-api-1.42/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_42/logs/ApplicationLogRecordBuilder142.java

@@ -13,12 +13,13 @@ import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
 
-class ApplicationLogRecordBuilder142 extends ApplicationLogRecordBuilder
+public class ApplicationLogRecordBuilder142 extends ApplicationLogRecordBuilder
     implements LogRecordBuilder {
 
   private final io.opentelemetry.api.logs.LogRecordBuilder agentLogRecordBuilder;
 
-  ApplicationLogRecordBuilder142(io.opentelemetry.api.logs.LogRecordBuilder agentLogRecordBuilder) {
+  public ApplicationLogRecordBuilder142(
+      io.opentelemetry.api.logs.LogRecordBuilder agentLogRecordBuilder) {
     super(agentLogRecordBuilder);
     this.agentLogRecordBuilder = agentLogRecordBuilder;
   }

instrumentation/opentelemetry-api/opentelemetry-api-1.42/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_42/logs/LoggerTest.java

@@ -6,6 +6,7 @@
 package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_42.logs;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.awaitility.Awaitility.await;
 
 import io.opentelemetry.api.GlobalOpenTelemetry;
@@ -54,6 +55,12 @@ class LoggerTest {
             .build();
   }
 
+  @Test
+  void incubatingApiNotAvailable() {
+    assertThatThrownBy(() -> Class.forName("io.opentelemetry.api.incubator.logs.ExtendedLogger"))
+        .isInstanceOf(ClassNotFoundException.class);
+  }
+
   @Test
   void logRecordBuilder() {
     SpanContext spanContext =

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/build.gradle.kts

@@ -0,0 +1,22 @@
+plugins {
+  id("otel.javaagent-instrumentation")
+}
+
+dependencies {
+  compileOnly(project(":opentelemetry-api-shaded-for-instrumenting", configuration = "v1_47"))
+  compileOnly("io.opentelemetry:opentelemetry-api-incubator")
+
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.0:javaagent"))
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.4:javaagent"))
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.10:javaagent"))
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.15:javaagent"))
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.27:javaagent"))
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.31:javaagent"))
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.32:javaagent"))
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.37:javaagent"))
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.38:javaagent"))
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.40:javaagent"))
+  implementation(project(":instrumentation:opentelemetry-api:opentelemetry-api-1.42:javaagent"))
+
+  testImplementation("io.opentelemetry:opentelemetry-api-incubator")
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_47/incubator/OpenTelemetryApiIncubatorInstrumentationModule.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator;
+
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasClassesNamed;
+import static java.util.Collections.singletonList;
+
+import com.google.auto.service.AutoService;
+import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.internal.ExperimentalInstrumentationModule;
+import java.util.List;
+import net.bytebuddy.matcher.ElementMatcher;
+
+@AutoService(InstrumentationModule.class)
+public class OpenTelemetryApiIncubatorInstrumentationModule extends InstrumentationModule
+    implements ExperimentalInstrumentationModule {
+  public OpenTelemetryApiIncubatorInstrumentationModule() {
+    super("opentelemetry-api", "opentelemetry-api-1.47", "opentelemetry-api-incubator-1.47");
+  }
+
+  @Override
+  public ElementMatcher.Junction<ClassLoader> classLoaderMatcher() {
+    return hasClassesNamed("application.io.opentelemetry.api.incubator.logs.ExtendedLogger");
+  }
+
+  @Override
+  public List<TypeInstrumentation> typeInstrumentations() {
+    return singletonList(new OpenTelemetryIncubatorInstrumentation());
+  }
+
+  @Override
+  public String getModuleGroup() {
+    return "opentelemetry-api-bridge";
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_47/incubator/OpenTelemetryIncubatorInstrumentation.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator;
+
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.none;
+
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_40.incubator.metrics.ApplicationMeterFactory140Incubator;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator.logs.ApplicationLoggerFactory147Incubator;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator.trace.ApplicationTracerFactory147Incubator;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+public class OpenTelemetryIncubatorInstrumentation implements TypeInstrumentation {
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return named("application.io.opentelemetry.api.GlobalOpenTelemetry");
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        none(), OpenTelemetryIncubatorInstrumentation.class.getName() + "$InitAdvice");
+  }
+
+  @SuppressWarnings({"ReturnValueIgnored", "unused"})
+  public static class InitAdvice {
+    @Advice.OnMethodEnter
+    public static void init() {
+      // the sole purpose of this advice is to ensure that ApplicationLoggerFactory147Incubator is
+      // recognized as helper class and injected into class loader
+      ApplicationLoggerFactory147Incubator.class.getName();
+      // 1.40 instrumentation does not apply on 1.47, we include only the metrics part here
+      ApplicationMeterFactory140Incubator.class.getName();
+      ApplicationTracerFactory147Incubator.class.getName();
+    }
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_47/incubator/logs/ApplicationLogRecordBuilder147Incubator.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator.logs;
+
+import application.io.opentelemetry.api.incubator.logs.ExtendedLogRecordBuilder;
+import io.opentelemetry.api.logs.LogRecordBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_42.logs.ApplicationLogRecordBuilder142;
+
+public class ApplicationLogRecordBuilder147Incubator extends ApplicationLogRecordBuilder142
+    implements ExtendedLogRecordBuilder {
+
+  private final io.opentelemetry.api.logs.LogRecordBuilder agentLogRecordBuilder;
+
+  ApplicationLogRecordBuilder147Incubator(LogRecordBuilder agentLogRecordBuilder) {
+    super(agentLogRecordBuilder);
+    this.agentLogRecordBuilder = agentLogRecordBuilder;
+  }
+
+  @Override
+  public ExtendedLogRecordBuilder setEventName(String eventName) {
+    ((io.opentelemetry.api.incubator.logs.ExtendedLogRecordBuilder) agentLogRecordBuilder)
+        .setEventName(eventName);
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_47/incubator/logs/ApplicationLogger147Incubator.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator.logs;
+
+import application.io.opentelemetry.api.incubator.logs.ExtendedLogRecordBuilder;
+import application.io.opentelemetry.api.incubator.logs.ExtendedLogger;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_27.logs.ApplicationLogger;
+
+class ApplicationLogger147Incubator extends ApplicationLogger implements ExtendedLogger {
+
+  private final io.opentelemetry.api.logs.Logger agentLogger;
+
+  ApplicationLogger147Incubator(io.opentelemetry.api.logs.Logger agentLogger) {
+    super(agentLogger);
+    this.agentLogger = agentLogger;
+  }
+
+  @Override
+  public boolean isEnabled() {
+    return ((io.opentelemetry.api.incubator.logs.ExtendedLogger) agentLogger).isEnabled();
+  }
+
+  @Override
+  public ExtendedLogRecordBuilder logRecordBuilder() {
+    return new ApplicationLogRecordBuilder147Incubator(agentLogger.logRecordBuilder());
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_47/incubator/logs/ApplicationLoggerFactory147Incubator.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator.logs;
+
+import io.opentelemetry.api.logs.Logger;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_27.logs.ApplicationLogger;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_27.logs.ApplicationLoggerFactory;
+
+// this class is used from opentelemetry-api-1.27.0 via reflection
+public class ApplicationLoggerFactory147Incubator implements ApplicationLoggerFactory {
+
+  @Override
+  public ApplicationLogger newLogger(Logger agentLogger) {
+    return new ApplicationLogger147Incubator(agentLogger);
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_47/incubator/trace/ApplicationTracer147Incubator.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator.trace;
+
+import application.io.opentelemetry.api.incubator.trace.ExtendedSpanBuilder;
+import application.io.opentelemetry.api.incubator.trace.ExtendedTracer;
+import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.ApplicationTracer;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_40.incubator.trace.ApplicationSpanBuilder140Incubator;
+
+final class ApplicationTracer147Incubator extends ApplicationTracer implements ExtendedTracer {
+
+  private final Tracer agentTracer;
+
+  ApplicationTracer147Incubator(Tracer agentTracer) {
+    super(agentTracer);
+    this.agentTracer = agentTracer;
+  }
+
+  @Override
+  public ExtendedSpanBuilder spanBuilder(String spanName) {
+    return new ApplicationSpanBuilder140Incubator(agentTracer.spanBuilder(spanName));
+  }
+
+  @Override
+  public boolean isEnabled() {
+    return ((io.opentelemetry.api.incubator.trace.ExtendedTracer) agentTracer).isEnabled();
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_47/incubator/trace/ApplicationTracerFactory147Incubator.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.incubator.trace;
+
+import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.ApplicationTracer;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.ApplicationTracerFactory;
+
+// this class is used from opentelemetry-api-1.27.0 via reflection
+public class ApplicationTracerFactory147Incubator implements ApplicationTracerFactory {
+
+  @Override
+  public ApplicationTracer newTracer(Tracer agentTracer) {
+    return new ApplicationTracer147Incubator(agentTracer);
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_47/logs/LoggerTest.java

@@ -0,0 +1,149 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.logs;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
+
+import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.KeyValue;
+import io.opentelemetry.api.common.Value;
+import io.opentelemetry.api.common.ValueType;
+import io.opentelemetry.api.incubator.logs.ExtendedLogger;
+import io.opentelemetry.api.logs.Logger;
+import io.opentelemetry.api.logs.Severity;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.api.trace.TraceFlags;
+import io.opentelemetry.api.trace.TraceState;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
+import io.opentelemetry.sdk.logs.data.internal.ExtendedLogRecordData;
+import io.opentelemetry.sdk.trace.IdGenerator;
+import java.time.Instant;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInfo;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class LoggerTest {
+
+  @RegisterExtension
+  static final AgentInstrumentationExtension testing = AgentInstrumentationExtension.create();
+
+  private String instrumentationName;
+  private Logger logger;
+
+  @BeforeEach
+  void setupLogger(TestInfo test) {
+    instrumentationName = "test-" + test.getDisplayName();
+    logger =
+        GlobalOpenTelemetry.get()
+            .getLogsBridge()
+            .loggerBuilder(instrumentationName)
+            .setInstrumentationVersion("1.2.3")
+            .setSchemaUrl("http://schema.org")
+            .build();
+  }
+
+  @Test
+  void logRecordBuilder() {
+    assertThat(logger).isInstanceOf(ExtendedLogger.class);
+
+    SpanContext spanContext =
+        SpanContext.create(
+            IdGenerator.random().generateTraceId(),
+            IdGenerator.random().generateSpanId(),
+            TraceFlags.getDefault(),
+            TraceState.getDefault());
+
+    ((ExtendedLogger) logger)
+        .logRecordBuilder()
+        .setEventName("eventName")
+        .setTimestamp(1, TimeUnit.SECONDS)
+        .setTimestamp(Instant.now())
+        .setContext(Context.current().with(Span.wrap(spanContext)))
+        .setSeverity(Severity.DEBUG)
+        .setSeverityText("debug")
+        .setBody("body")
+        .setAttribute(AttributeKey.stringKey("key"), "value")
+        .setAllAttributes(Attributes.builder().put("key", "value").build())
+        .emit();
+
+    await()
+        .untilAsserted(
+            () ->
+                assertThat(testing.logRecords())
+                    .satisfiesExactly(
+                        logRecordData -> {
+                          assertThat(logRecordData.getInstrumentationScopeInfo().getName())
+                              .isEqualTo(instrumentationName);
+                          assertThat(((ExtendedLogRecordData) logRecordData).getEventName())
+                              .isEqualTo("eventName");
+                          assertThat(logRecordData.getInstrumentationScopeInfo().getVersion())
+                              .isEqualTo("1.2.3");
+                          assertThat(logRecordData.getTimestampEpochNanos()).isGreaterThan(0);
+                          assertThat(logRecordData.getSpanContext()).isEqualTo(spanContext);
+                          assertThat(logRecordData.getSeverity()).isEqualTo(Severity.DEBUG);
+                          assertThat(logRecordData.getSeverityText()).isEqualTo("debug");
+                          assertThat(logRecordData.getBodyValue().getType())
+                              .isEqualTo(ValueType.STRING);
+                          assertThat(logRecordData.getBodyValue().getValue()).isEqualTo("body");
+                          assertThat(logRecordData.getAttributes())
+                              .isEqualTo(Attributes.builder().put("key", "value").build());
+                        }));
+  }
+
+  private static Stream<Arguments> bodyValues() {
+    return Stream.of(
+        Arguments.of(Value.of("hello")),
+        Arguments.of(Value.of(42)),
+        Arguments.of(Value.of(42.42)),
+        Arguments.of(Value.of(true)),
+        Arguments.of(Value.of(new byte[] {4, 2})),
+        Arguments.of(Value.of(Value.of("hello"), Value.of(42))),
+        Arguments.of(Value.of(KeyValue.of("key", Value.of(42)))));
+  }
+
+  @ParameterizedTest
+  @MethodSource("bodyValues")
+  void logBodyValue() {
+    Value<?> value = Value.of(42);
+    logger.logRecordBuilder().setBody(value).emit();
+
+    await()
+        .untilAsserted(
+            () ->
+                assertThat(testing.logRecords())
+                    .satisfiesExactly(
+                        logRecordData -> {
+                          assertThat(logRecordData.getBodyValue().getType())
+                              .isEqualTo(value.getType());
+                          assertThat(logRecordData.getBodyValue().getValue())
+                              .isEqualTo(value.getValue());
+                        }));
+  }
+
+  @Test
+  void logNullBody() {
+    Value<?> value = null;
+    logger.logRecordBuilder().setBody(value).emit();
+
+    await()
+        .untilAsserted(
+            () ->
+                assertThat(testing.logRecords())
+                    .satisfiesExactly(
+                        logRecordData -> assertThat(logRecordData.getBodyValue()).isNull()));
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_47/metrics/MeterTest.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.metrics;
+
+import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
+
+import io.opentelemetry.api.incubator.metrics.ExtendedDoubleCounter;
+import io.opentelemetry.api.incubator.metrics.ExtendedDoubleGauge;
+import io.opentelemetry.api.incubator.metrics.ExtendedDoubleHistogram;
+import io.opentelemetry.api.incubator.metrics.ExtendedDoubleUpDownCounter;
+import io.opentelemetry.api.incubator.metrics.ExtendedLongCounter;
+import io.opentelemetry.api.incubator.metrics.ExtendedLongGauge;
+import io.opentelemetry.api.incubator.metrics.ExtendedLongHistogram;
+import io.opentelemetry.api.incubator.metrics.ExtendedLongUpDownCounter;
+import io.opentelemetry.api.metrics.DoubleCounter;
+import io.opentelemetry.api.metrics.DoubleGauge;
+import io.opentelemetry.api.metrics.DoubleGaugeBuilder;
+import io.opentelemetry.api.metrics.DoubleHistogram;
+import io.opentelemetry.api.metrics.DoubleHistogramBuilder;
+import io.opentelemetry.api.metrics.DoubleUpDownCounter;
+import io.opentelemetry.api.metrics.LongCounter;
+import io.opentelemetry.api.metrics.LongCounterBuilder;
+import io.opentelemetry.api.metrics.LongGauge;
+import io.opentelemetry.api.metrics.LongHistogram;
+import io.opentelemetry.api.metrics.LongUpDownCounter;
+import io.opentelemetry.api.metrics.LongUpDownCounterBuilder;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+class MeterTest {
+
+  @RegisterExtension
+  static final AgentInstrumentationExtension testing = AgentInstrumentationExtension.create();
+
+  @Test
+  void isEnabled() {
+    Meter disabledMeter = testing.getOpenTelemetry().getMeter("disabled-meter");
+    Meter enabledMeter = testing.getOpenTelemetry().getMeter("enabled-meter");
+    testEnabled(disabledMeter, false);
+    testEnabled(enabledMeter, true);
+  }
+
+  private static void testEnabled(Meter meter, boolean expected) {
+    LongCounterBuilder counterBuilder = meter.counterBuilder("test");
+    LongCounter longCounter = counterBuilder.build();
+    assertThat(longCounter).isInstanceOf(ExtendedLongCounter.class);
+    assertThat(((ExtendedLongCounter) longCounter).isEnabled()).isEqualTo(expected);
+
+    DoubleCounter doubleCounter = counterBuilder.ofDoubles().build();
+    assertThat(doubleCounter).isInstanceOf(ExtendedDoubleCounter.class);
+    assertThat(((ExtendedDoubleCounter) doubleCounter).isEnabled()).isEqualTo(expected);
+
+    LongUpDownCounterBuilder upDownCounterBuilder = meter.upDownCounterBuilder("test");
+    LongUpDownCounter longUpDownCounter = upDownCounterBuilder.build();
+    assertThat(longUpDownCounter).isInstanceOf(ExtendedLongUpDownCounter.class);
+    assertThat(((ExtendedLongUpDownCounter) longUpDownCounter).isEnabled()).isEqualTo(expected);
+
+    DoubleUpDownCounter doubleUpDownCounter = upDownCounterBuilder.ofDoubles().build();
+    assertThat(doubleUpDownCounter).isInstanceOf(ExtendedDoubleUpDownCounter.class);
+    assertThat(((ExtendedDoubleUpDownCounter) doubleUpDownCounter).isEnabled()).isEqualTo(expected);
+
+    DoubleGaugeBuilder gaugeBuilder = meter.gaugeBuilder("test");
+    DoubleGauge doubleGauge = gaugeBuilder.build();
+    assertThat(doubleGauge).isInstanceOf(ExtendedDoubleGauge.class);
+    assertThat(((ExtendedDoubleGauge) doubleGauge).isEnabled()).isEqualTo(expected);
+
+    LongGauge longGauge = gaugeBuilder.ofLongs().build();
+    assertThat(longGauge).isInstanceOf(ExtendedLongGauge.class);
+    assertThat(((ExtendedLongGauge) longGauge).isEnabled()).isEqualTo(expected);
+
+    DoubleHistogramBuilder histogramBuilder = meter.histogramBuilder("test");
+    DoubleHistogram doubleHistogram = histogramBuilder.build();
+    assertThat(doubleHistogram).isInstanceOf(ExtendedDoubleHistogram.class);
+    assertThat(((ExtendedDoubleHistogram) doubleHistogram).isEnabled()).isEqualTo(expected);
+
+    LongHistogram longHistogram = histogramBuilder.ofLongs().build();
+    assertThat(longHistogram).isInstanceOf(ExtendedLongHistogram.class);
+    assertThat(((ExtendedLongHistogram) longHistogram).isEnabled()).isEqualTo(expected);
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.47/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_47/trace/TracerTest.java

@@ -0,0 +1,117 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_47.trace;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import io.opentelemetry.api.incubator.trace.ExtendedSpanBuilder;
+import io.opentelemetry.api.incubator.trace.ExtendedTracer;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.api.trace.SpanId;
+import io.opentelemetry.api.trace.TraceFlags;
+import io.opentelemetry.api.trace.TraceId;
+import io.opentelemetry.api.trace.TraceState;
+import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.propagation.ContextPropagators;
+import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
+import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+class TracerTest {
+
+  @RegisterExtension
+  private static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
+
+  @Test
+  void isEnabled() {
+    Tracer disabledTracer = testing.getOpenTelemetry().getTracer("disabled-tracer");
+    Tracer enabledTracer = testing.getOpenTelemetry().getTracer("enabled-tracer");
+    testEnabled(disabledTracer, false);
+    testEnabled(enabledTracer, true);
+  }
+
+  private static void testEnabled(Tracer tracer, boolean expected) {
+    assertThat(tracer).isInstanceOf(ExtendedTracer.class);
+    assertThat(((ExtendedTracer) tracer).isEnabled()).isEqualTo(expected);
+  }
+
+  @Test
+  void extendedSpanBuilder() {
+    Tracer tracer = testing.getOpenTelemetry().getTracer("test");
+    assertThat(tracer).isInstanceOf(ExtendedTracer.class);
+    ExtendedTracer extendedTracer = (ExtendedTracer) tracer;
+
+    ExtendedSpanBuilder builder = extendedTracer.spanBuilder("test");
+    {
+      Span span = builder.startAndCall(Span::current);
+      assertThat(span.getSpanContext().getTraceId()).isNotEqualTo(TraceId.getInvalid());
+    }
+    {
+      Span span = builder.startAndCall(Span::current, (s, t) -> {});
+      assertThat(span.getSpanContext().getTraceId()).isNotEqualTo(TraceId.getInvalid());
+    }
+    {
+      AtomicReference<Span> spanRef = new AtomicReference<>();
+      assertThatThrownBy(
+              () ->
+                  builder.startAndCall(
+                      () -> {
+                        throw new IllegalStateException("fail");
+                      },
+                      (s, t) -> spanRef.set(s)))
+          .isInstanceOf(IllegalStateException.class);
+      assertThat(spanRef.get().getSpanContext().getTraceId()).isNotEqualTo(TraceId.getInvalid());
+    }
+
+    {
+      AtomicReference<Span> spanRef = new AtomicReference<>();
+      builder.startAndRun(() -> spanRef.set(Span.current()));
+      assertThat(spanRef.get().getSpanContext().getTraceId()).isNotEqualTo(TraceId.getInvalid());
+    }
+    {
+      AtomicReference<Span> spanRef = new AtomicReference<>();
+      builder.startAndRun(() -> spanRef.set(Span.current()), (s, t) -> {});
+      assertThat(spanRef.get().getSpanContext().getTraceId()).isNotEqualTo(TraceId.getInvalid());
+    }
+    {
+      AtomicReference<Span> spanRef = new AtomicReference<>();
+      assertThatThrownBy(
+              () ->
+                  builder.startAndRun(
+                      () -> {
+                        throw new IllegalStateException("fail");
+                      },
+                      (s, t) -> spanRef.set(s)))
+          .isInstanceOf(IllegalStateException.class);
+      assertThat(spanRef.get().getSpanContext().getTraceId()).isNotEqualTo(TraceId.getInvalid());
+    }
+
+    Map<String, String> map = new HashMap<>();
+    Context context =
+        Context.root()
+            .with(
+                Span.wrap(
+                    SpanContext.create(
+                        TraceId.fromLongs(0, 1),
+                        SpanId.fromLong(2),
+                        TraceFlags.getDefault(),
+                        TraceState.getDefault())));
+
+    W3CTraceContextPropagator.getInstance()
+        .inject(context, map, (m, key, value) -> m.put(key, value));
+    builder.setParentFrom(ContextPropagators.create(W3CTraceContextPropagator.getInstance()), map);
+    Span span = builder.startSpan();
+    assertThat(span.getSpanContext().getTraceId()).isEqualTo(TraceId.fromLongs(0, 1));
+  }
+}

instrumentation/runtime-telemetry/runtime-telemetry-java8/javaagent/src/main/java/io/opentelemetry/instrumentation/javaagent/runtimemetrics/java8/JarAnalyzer.java

@@ -13,8 +13,7 @@ import io.opentelemetry.api.OpenTelemetry;
 import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.common.AttributesBuilder;
-import io.opentelemetry.api.incubator.events.EventLogger;
+import io.opentelemetry.api.incubator.logs.ExtendedLogRecordBuilder;
-import io.opentelemetry.api.incubator.events.GlobalEventLoggerProvider;
 import io.opentelemetry.instrumentation.runtimemetrics.java8.internal.JmxRuntimeMetricsUtil;
 import io.opentelemetry.sdk.common.Clock;
 import io.opentelemetry.sdk.internal.DaemonThreadFactory;
@@ -57,14 +56,16 @@ final class JarAnalyzer implements ClassFileTransformer {
   private final Set<URI> seenUris = new HashSet<>();
   private final BlockingQueue<URL> toProcess = new LinkedBlockingDeque<>();
 
-  private JarAnalyzer(OpenTelemetry unused, int jarsPerSecond) {
+  private JarAnalyzer(OpenTelemetry openTelemetry, int jarsPerSecond) {
-    // TODO(jack-berg): Use OpenTelemetry to obtain EventLogger when event API is stable
+    ExtendedLogRecordBuilder logRecordBuilder =
-    EventLogger eventLogger =
+        (ExtendedLogRecordBuilder)
-        GlobalEventLoggerProvider.get()
+            openTelemetry
-            .eventLoggerBuilder(JmxRuntimeMetricsUtil.getInstrumentationName())
+                .getLogsBridge()
-            .setInstrumentationVersion(JmxRuntimeMetricsUtil.getInstrumentationVersion())
+                .loggerBuilder(JmxRuntimeMetricsUtil.getInstrumentationName())
-            .build();
+                .setInstrumentationVersion(JmxRuntimeMetricsUtil.getInstrumentationVersion())
-    Worker worker = new Worker(eventLogger, toProcess, jarsPerSecond);
+                .build()
+                .logRecordBuilder();
+    Worker worker = new Worker(logRecordBuilder, toProcess, jarsPerSecond);
     Thread workerThread =
         new DaemonThreadFactory(JarAnalyzer.class.getSimpleName() + "_WorkerThread")
             .newThread(worker);
@@ -152,11 +153,12 @@ final class JarAnalyzer implements ClassFileTransformer {
 
   private static final class Worker implements Runnable {
 
-    private final EventLogger eventLogger;
+    private final ExtendedLogRecordBuilder eventLogger;
     private final BlockingQueue<URL> toProcess;
     private final io.opentelemetry.sdk.internal.RateLimiter rateLimiter;
 
-    private Worker(EventLogger eventLogger, BlockingQueue<URL> toProcess, int jarsPerSecond) {
+    private Worker(
+        ExtendedLogRecordBuilder eventLogger, BlockingQueue<URL> toProcess, int jarsPerSecond) {
       this.eventLogger = eventLogger;
       this.toProcess = toProcess;
       this.rateLimiter =
@@ -166,7 +168,7 @@ final class JarAnalyzer implements ClassFileTransformer {
 
     /**
      * Continuously poll the {@link #toProcess} for archive {@link URL}s, and process each wit
-     * {@link #processUrl(EventLogger, URL)}.
+     * {@link #processUrl(ExtendedLogRecordBuilder, URL)}.
      */
     @Override
     public void run() {
@@ -200,7 +202,7 @@ final class JarAnalyzer implements ClassFileTransformer {
    * Process the {@code archiveUrl}, extracting metadata from it and emitting an event with the
    * content.
    */
-  static void processUrl(EventLogger eventLogger, URL archiveUrl) {
+  static void processUrl(ExtendedLogRecordBuilder eventLogger, URL archiveUrl) {
     JarDetails jarDetails;
     try {
       jarDetails = JarDetails.forUrl(archiveUrl);
@@ -239,6 +241,6 @@ final class JarAnalyzer implements ClassFileTransformer {
     builder.put(PACKAGE_CHECKSUM, packageChecksum);
     builder.put(PACKAGE_CHECKSUM_ALGORITHM, "SHA1");
 
-    eventLogger.builder(EVENT_NAME_INFO).setAttributes(builder.build()).emit();
+    eventLogger.setEventName(EVENT_NAME_INFO).setAllAttributes(builder.build()).emit();
   }
 }

instrumentation/runtime-telemetry/runtime-telemetry-java8/javaagent/src/test/java/io/opentelemetry/instrumentation/javaagent/runtimemetrics/java8/JarAnalyzerInstallerTest.java

@@ -12,6 +12,7 @@ import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
 import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
 import io.opentelemetry.sdk.logs.data.LogRecordData;
+import io.opentelemetry.sdk.logs.data.internal.ExtendedLogRecordData;
 import java.util.List;
 import org.awaitility.Awaitility;
 import org.junit.jupiter.api.Test;
@@ -39,10 +40,7 @@ class JarAnalyzerInstallerTest {
                         .filter(
                             record ->
                                 "package.info"
-                                    .equals(
+                                    .equals(((ExtendedLogRecordData) record).getEventName()))
-                                        record
-                                            .getAttributes()
-                                            .get(AttributeKey.stringKey("event.name"))))
                         .collect(toList()),
                 (eventList) -> !eventList.isEmpty());
 

instrumentation/runtime-telemetry/runtime-telemetry-java8/testing/src/test/java/io/opentelemetry/instrumentation/javaagent/runtimemetrics/java8/JarAnalyzerTest.java

@@ -21,8 +21,7 @@ import static org.mockito.Mockito.when;
 
 import com.google.common.collect.ImmutableMap;
 import io.opentelemetry.api.common.Attributes;
-import io.opentelemetry.api.incubator.events.EventBuilder;
+import io.opentelemetry.api.incubator.logs.ExtendedLogRecordBuilder;
-import io.opentelemetry.api.incubator.events.EventLogger;
 import io.opentelemetry.api.trace.Tracer;
 import io.opentelemetry.sdk.testing.assertj.AttributesAssert;
 import java.io.File;
@@ -41,15 +40,14 @@ class JarAnalyzerTest {
   @ParameterizedTest
   @MethodSource("processUrlArguments")
   void processUrl_EmitsEvents(URL archiveUrl, Consumer<AttributesAssert> attributesConsumer) {
-    EventLogger eventLogger = mock(EventLogger.class);
+    ExtendedLogRecordBuilder builder = mock(ExtendedLogRecordBuilder.class);
-    EventBuilder builder = mock(EventBuilder.class);
+    when(builder.setEventName(eq("package.info"))).thenReturn(builder);
-    when(eventLogger.builder(eq("package.info"))).thenReturn(builder);
+    when(builder.setAllAttributes(any())).thenReturn(builder);
-    when(builder.setAttributes(any())).thenReturn(builder);
 
-    JarAnalyzer.processUrl(eventLogger, archiveUrl);
+    JarAnalyzer.processUrl(builder, archiveUrl);
 
     ArgumentCaptor<Attributes> attributesArgumentCaptor = ArgumentCaptor.forClass(Attributes.class);
-    verify(builder).setAttributes(attributesArgumentCaptor.capture());
+    verify(builder).setAllAttributes(attributesArgumentCaptor.capture());
 
     attributesConsumer.accept(assertThat(attributesArgumentCaptor.getValue()));
   }

javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/OpenTelemetryInstallerTest.groovy

@@ -7,19 +7,16 @@ package io.opentelemetry.javaagent.tooling
 
 import io.opentelemetry.api.GlobalOpenTelemetry
 import io.opentelemetry.api.OpenTelemetry
-import io.opentelemetry.api.incubator.events.GlobalEventLoggerProvider
 import spock.lang.Specification
 
 class OpenTelemetryInstallerTest extends Specification {
 
   void setup() {
     GlobalOpenTelemetry.resetForTest()
-    GlobalEventLoggerProvider.resetForTest()
   }
 
   void cleanup() {
     GlobalOpenTelemetry.resetForTest()
-    GlobalEventLoggerProvider.resetForTest()
   }
 
   def "should initialize GlobalOpenTelemetry"() {

javaagent-tooling/src/test/java/io/opentelemetry/javaagent/tooling/config/ConfigurationPropertiesSupplierTest.java

@@ -10,7 +10,6 @@ import static java.util.Collections.singletonMap;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import io.opentelemetry.api.GlobalOpenTelemetry;
-import io.opentelemetry.api.incubator.events.GlobalEventLoggerProvider;
 import io.opentelemetry.javaagent.tooling.OpenTelemetryInstaller;
 import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
 import io.opentelemetry.sdk.autoconfigure.internal.AutoConfigureUtil;
@@ -33,7 +32,6 @@ class ConfigurationPropertiesSupplierTest {
   @AfterAll
   static void cleanUp() {
     GlobalOpenTelemetry.resetForTest();
-    GlobalEventLoggerProvider.resetForTest();
   }
 
   // regression for https://github.com/open-telemetry/opentelemetry-java-instrumentation/issues/6696

javaagent-tooling/src/test/java/io/opentelemetry/javaagent/tooling/config/OtlpProtocolPropertiesSupplierTest.java

@@ -8,7 +8,6 @@ package io.opentelemetry.javaagent.tooling.config;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import io.opentelemetry.api.GlobalOpenTelemetry;
-import io.opentelemetry.api.incubator.events.GlobalEventLoggerProvider;
 import io.opentelemetry.javaagent.tooling.OpenTelemetryInstaller;
 import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
 import io.opentelemetry.sdk.autoconfigure.internal.AutoConfigureUtil;
@@ -21,7 +20,6 @@ class OtlpProtocolPropertiesSupplierTest {
   @AfterEach
   void cleanUp() {
     GlobalOpenTelemetry.resetForTest();
-    GlobalEventLoggerProvider.resetForTest();
   }
 
   @SetSystemProperty(

licenses/licenses.md

@@ -62,91 +62,91 @@
 > - **POM Project URL**: [https://github.com/square/okio/](https://github.com/square/okio/)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**12** **Group:** `io.opentelemetry` **Name:** `opentelemetry-api` **Version:** `1.46.0`
+**12** **Group:** `io.opentelemetry` **Name:** `opentelemetry-api` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
 
-**13** **Group:** `io.opentelemetry` **Name:** `opentelemetry-api-incubator` **Version:** `1.46.0-alpha`
+**13** **Group:** `io.opentelemetry` **Name:** `opentelemetry-api-incubator` **Version:** `1.47.0-alpha`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
 
-**14** **Group:** `io.opentelemetry` **Name:** `opentelemetry-context` **Version:** `1.46.0`
+**14** **Group:** `io.opentelemetry` **Name:** `opentelemetry-context` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
 
-**15** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-common` **Version:** `1.46.0`
+**15** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-common` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**16** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-logging` **Version:** `1.46.0`
+**16** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-logging` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**17** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-logging-otlp` **Version:** `1.46.0`
+**17** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-logging-otlp` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**18** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-otlp` **Version:** `1.46.0`
+**18** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-otlp` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**19** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-otlp-common` **Version:** `1.46.0`
+**19** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-otlp-common` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**20** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-prometheus` **Version:** `1.46.0-alpha`
+**20** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-prometheus` **Version:** `1.47.0-alpha`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**21** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-sender-okhttp` **Version:** `1.46.0`
+**21** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-sender-okhttp` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**22** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-zipkin` **Version:** `1.46.0`
+**22** **Group:** `io.opentelemetry` **Name:** `opentelemetry-exporter-zipkin` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**23** **Group:** `io.opentelemetry` **Name:** `opentelemetry-extension-kotlin` **Version:** `1.46.0`
+**23** **Group:** `io.opentelemetry` **Name:** `opentelemetry-extension-kotlin` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**24** **Group:** `io.opentelemetry` **Name:** `opentelemetry-extension-trace-propagators` **Version:** `1.46.0`
+**24** **Group:** `io.opentelemetry` **Name:** `opentelemetry-extension-trace-propagators` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**25** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk` **Version:** `1.46.0`
+**25** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**26** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-common` **Version:** `1.46.0`
+**26** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-common` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**27** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-extension-autoconfigure` **Version:** `1.46.0`
+**27** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-extension-autoconfigure` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**28** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-extension-autoconfigure-spi` **Version:** `1.46.0`
+**28** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-extension-autoconfigure-spi` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**29** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-extension-incubator` **Version:** `1.46.0-alpha`
+**29** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-extension-incubator` **Version:** `1.47.0-alpha`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**30** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-extension-jaeger-remote-sampler` **Version:** `1.46.0`
+**30** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-extension-jaeger-remote-sampler` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**31** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-logs` **Version:** `1.46.0`
+**31** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-logs` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**32** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-metrics` **Version:** `1.46.0`
+**32** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-metrics` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**33** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-trace` **Version:** `1.46.0`
+**33** **Group:** `io.opentelemetry` **Name:** `opentelemetry-sdk-trace` **Version:** `1.47.0`
 > - **POM Project URL**: [https://github.com/open-telemetry/opentelemetry-java](https://github.com/open-telemetry/opentelemetry-java)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
@@ -225,15 +225,15 @@
 > - **POM Project URL**: [http://www.jetbrains.org](http://www.jetbrains.org)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**51** **Group:** `org.jetbrains.kotlin` **Name:** `kotlin-stdlib` **Version:** `2.1.0`
+**51** **Group:** `org.jetbrains.kotlin` **Name:** `kotlin-stdlib` **Version:** `2.1.10`
 > - **POM Project URL**: [https://kotlinlang.org/](https://kotlinlang.org/)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**52** **Group:** `org.jetbrains.kotlin` **Name:** `kotlin-stdlib-jdk7` **Version:** `2.1.0`
+**52** **Group:** `org.jetbrains.kotlin` **Name:** `kotlin-stdlib-jdk7` **Version:** `2.1.10`
 > - **POM Project URL**: [https://kotlinlang.org/](https://kotlinlang.org/)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 
-**53** **Group:** `org.jetbrains.kotlin` **Name:** `kotlin-stdlib-jdk8` **Version:** `2.1.0`
+**53** **Group:** `org.jetbrains.kotlin` **Name:** `kotlin-stdlib-jdk8` **Version:** `2.1.10`
 > - **POM Project URL**: [https://kotlinlang.org/](https://kotlinlang.org/)
 > - **POM License**: Apache License, Version 2.0 - [https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)
 

opentelemetry-api-shaded-for-instrumenting/build.gradle.kts

@@ -72,6 +72,13 @@ val v1_42Deps by configurations.creating {
   exclude("io.opentelemetry", "opentelemetry-bom")
   exclude("io.opentelemetry", "opentelemetry-bom-alpha")
 }
+val v1_47Deps by configurations.creating {
+  isCanBeResolved = true
+  isCanBeConsumed = false
+  // exclude the bom added by dependencyManagement
+  exclude("io.opentelemetry", "opentelemetry-bom")
+  exclude("io.opentelemetry", "opentelemetry-bom-alpha")
+}
 // configuration for publishing the shadowed artifact
 val v1_10 by configurations.creating {
   isCanBeConsumed = true
@@ -109,6 +116,10 @@ val v1_42 by configurations.creating {
   isCanBeConsumed = true
   isCanBeResolved = false
 }
+val v1_47 by configurations.creating {
+  isCanBeConsumed = true
+  isCanBeResolved = false
+}
 
 dependencies {
   latestDeps("io.opentelemetry:opentelemetry-api")
@@ -175,6 +186,11 @@ dependencies {
         strictly("1.42.0-alpha")
       }
     }
+    v1_47Deps("io.opentelemetry:$it") {
+      version {
+        strictly("1.47.0-alpha")
+      }
+    }
   }
 }
 
@@ -226,6 +242,10 @@ tasks {
     configurations = listOf(v1_42Deps)
     archiveClassifier.set("v1_42")
   }
+  val v1_47Shadow by registering(ShadowJar::class) {
+    configurations = listOf(v1_47Deps)
+    archiveClassifier.set("v1_47")
+  }
 
   artifacts {
     add(v1_10.name, v1_10Shadow)
@@ -237,5 +257,6 @@ tasks {
     add(v1_38.name, v1_38Shadow)
     add(v1_40.name, v1_40Shadow)
     add(v1_42.name, v1_42Shadow)
+    add(v1_47.name, v1_47Shadow)
   }
 }

settings.gradle.kts

@@ -426,6 +426,7 @@ include(":instrumentation:opentelemetry-api:opentelemetry-api-1.37:javaagent")
 include(":instrumentation:opentelemetry-api:opentelemetry-api-1.38:javaagent")
 include(":instrumentation:opentelemetry-api:opentelemetry-api-1.40:javaagent")
 include(":instrumentation:opentelemetry-api:opentelemetry-api-1.42:javaagent")
+include(":instrumentation:opentelemetry-api:opentelemetry-api-1.47:javaagent")
 include(":instrumentation:opentelemetry-extension-annotations-1.0:javaagent")
 include(":instrumentation:opentelemetry-extension-kotlin-1.0:javaagent")
 include(":instrumentation:opentelemetry-instrumentation-annotations-1.16:javaagent")

testing-common/src/main/java/io/opentelemetry/javaagent/testing/common/AgentTestingExporterAccess.java

@@ -42,6 +42,7 @@ import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableSummaryPointData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableValueAtQuantile;
 import io.opentelemetry.sdk.testing.logs.TestLogRecordData;
+import io.opentelemetry.sdk.testing.logs.internal.TestExtendedLogRecordData;
 import io.opentelemetry.sdk.testing.trace.TestSpanData;
 import io.opentelemetry.sdk.trace.data.EventData;
 import io.opentelemetry.sdk.trace.data.LinkData;
@@ -96,6 +97,8 @@ public final class AgentTestingExporterAccess {
   // opentelemetry-api-1.27:javaagent tests use an older version of opentelemetry-api where Value
   // class is missing
   private static final boolean canUseValue = classAvailable("io.opentelemetry.api.common.Value");
+  private static final boolean hasExtendedLogRecordData =
+      classAvailable("io.opentelemetry.sdk.logs.data.internal.ExtendedLogRecordData");
 
   static {
     try {
@@ -416,6 +419,9 @@ public final class AgentTestingExporterAccess {
       LogRecord logRecord,
       io.opentelemetry.sdk.resources.Resource resource,
       InstrumentationScopeInfo instrumentationScopeInfo) {
+    if (hasExtendedLogRecordData) {
+      return createExtendedLogData(logRecord, resource, instrumentationScopeInfo);
+    }
     TestLogRecordData.Builder builder =
         TestLogRecordData.builder()
             .setResource(resource)
@@ -438,6 +444,29 @@ public final class AgentTestingExporterAccess {
     return builder.build();
   }
 
+  private static LogRecordData createExtendedLogData(
+      LogRecord logRecord,
+      io.opentelemetry.sdk.resources.Resource resource,
+      InstrumentationScopeInfo instrumentationScopeInfo) {
+    TestExtendedLogRecordData.Builder builder =
+        TestExtendedLogRecordData.builder()
+            .setResource(resource)
+            .setInstrumentationScopeInfo(instrumentationScopeInfo)
+            .setTimestamp(logRecord.getTimeUnixNano(), TimeUnit.NANOSECONDS)
+            .setSpanContext(
+                SpanContext.create(
+                    bytesToHex(logRecord.getTraceId().toByteArray()),
+                    bytesToHex(logRecord.getSpanId().toByteArray()),
+                    TraceFlags.getDefault(),
+                    TraceState.getDefault()))
+            .setSeverity(fromProto(logRecord.getSeverityNumber()))
+            .setSeverityText(logRecord.getSeverityText())
+            .setAttributes(fromProto(logRecord.getAttributesList()))
+            .setEventName(logRecord.getEventName())
+            .setBodyValue(getBodyValue(logRecord.getBody()));
+    return builder.build();
+  }
+
   private static Value<?> getBodyValue(AnyValue value) {
     switch (value.getValueCase()) {
       case STRING_VALUE: