Bridge incubator metrics apis (#9884)

instrumentation/opentelemetry-api/opentelemetry-api-1.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/trace/Bridging.java

@@ -15,6 +15,8 @@ import application.io.opentelemetry.api.trace.SpanKind;
 import application.io.opentelemetry.api.trace.StatusCode;
 import application.io.opentelemetry.api.trace.TraceState;
 import application.io.opentelemetry.api.trace.TraceStateBuilder;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.logging.Logger;
 
 /**
@@ -143,6 +145,16 @@ public class Bridging {
     return null;
   }
 
+  public static List<io.opentelemetry.api.common.AttributeKey<?>> toAgent(
+      List<AttributeKey<?>> attributeKeys) {
+    List<io.opentelemetry.api.common.AttributeKey<?>> result =
+        new ArrayList<>(attributeKeys.size());
+    for (AttributeKey<?> attributeKey : attributeKeys) {
+      result.add(toAgent(attributeKey));
+    }
+    return result;
+  }
+
   public static io.opentelemetry.api.trace.StatusCode toAgent(StatusCode applicationStatus) {
     io.opentelemetry.api.trace.StatusCode agentCanonicalCode;
     try {

instrumentation/opentelemetry-api/opentelemetry-api-1.10/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_10/metrics/ApplicationDoubleCounterBuilder.java

@@ -12,11 +12,12 @@ import application.io.opentelemetry.api.metrics.ObservableDoubleMeasurement;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.util.function.Consumer;
 
-final class ApplicationDoubleCounterBuilder implements DoubleCounterBuilder {
+public class ApplicationDoubleCounterBuilder implements DoubleCounterBuilder {
 
   private final io.opentelemetry.api.metrics.DoubleCounterBuilder agentBuilder;
 
-  ApplicationDoubleCounterBuilder(io.opentelemetry.api.metrics.DoubleCounterBuilder agentBuilder) {
+  protected ApplicationDoubleCounterBuilder(
+      io.opentelemetry.api.metrics.DoubleCounterBuilder agentBuilder) {
     this.agentBuilder = agentBuilder;
   }
 

instrumentation/opentelemetry-api/opentelemetry-api-1.10/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_10/metrics/ApplicationDoubleGaugeBuilder.java

@@ -12,11 +12,12 @@ import application.io.opentelemetry.api.metrics.ObservableDoubleMeasurement;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.util.function.Consumer;
 
-final class ApplicationDoubleGaugeBuilder implements DoubleGaugeBuilder {
+public class ApplicationDoubleGaugeBuilder implements DoubleGaugeBuilder {
 
   private final io.opentelemetry.api.metrics.DoubleGaugeBuilder agentBuilder;
 
-  ApplicationDoubleGaugeBuilder(io.opentelemetry.api.metrics.DoubleGaugeBuilder agentBuilder) {
+  protected ApplicationDoubleGaugeBuilder(
+      io.opentelemetry.api.metrics.DoubleGaugeBuilder agentBuilder) {
     this.agentBuilder = agentBuilder;
   }
 

instrumentation/opentelemetry-api/opentelemetry-api-1.10/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_10/metrics/ApplicationDoubleHistogramBuilder.java

@@ -10,11 +10,11 @@ import application.io.opentelemetry.api.metrics.DoubleHistogramBuilder;
 import application.io.opentelemetry.api.metrics.LongHistogramBuilder;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 
-final class ApplicationDoubleHistogramBuilder implements DoubleHistogramBuilder {
+public class ApplicationDoubleHistogramBuilder implements DoubleHistogramBuilder {
 
   private final io.opentelemetry.api.metrics.DoubleHistogramBuilder agentBuilder;
 
-  ApplicationDoubleHistogramBuilder(
+  protected ApplicationDoubleHistogramBuilder(
       io.opentelemetry.api.metrics.DoubleHistogramBuilder agentBuilder) {
     this.agentBuilder = agentBuilder;
   }

instrumentation/opentelemetry-api/opentelemetry-api-1.10/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_10/metrics/ApplicationDoubleUpDownCounterBuilder.java

@@ -12,11 +12,11 @@ import application.io.opentelemetry.api.metrics.ObservableDoubleUpDownCounter;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.util.function.Consumer;
 
-final class ApplicationDoubleUpDownCounterBuilder implements DoubleUpDownCounterBuilder {
+public class ApplicationDoubleUpDownCounterBuilder implements DoubleUpDownCounterBuilder {
 
   private final io.opentelemetry.api.metrics.DoubleUpDownCounterBuilder agentBuilder;
 
-  ApplicationDoubleUpDownCounterBuilder(
+  protected ApplicationDoubleUpDownCounterBuilder(
       io.opentelemetry.api.metrics.DoubleUpDownCounterBuilder agentBuilder) {
     this.agentBuilder = agentBuilder;
   }

instrumentation/opentelemetry-api/opentelemetry-api-1.10/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_10/metrics/ApplicationLongCounterBuilder.java

@@ -13,11 +13,12 @@ import application.io.opentelemetry.api.metrics.ObservableLongMeasurement;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.util.function.Consumer;
 
-final class ApplicationLongCounterBuilder implements LongCounterBuilder {
+public class ApplicationLongCounterBuilder implements LongCounterBuilder {
 
   private final io.opentelemetry.api.metrics.LongCounterBuilder agentBuilder;
 
-  ApplicationLongCounterBuilder(io.opentelemetry.api.metrics.LongCounterBuilder agentBuilder) {
+  protected ApplicationLongCounterBuilder(
+      io.opentelemetry.api.metrics.LongCounterBuilder agentBuilder) {
     this.agentBuilder = agentBuilder;
   }
 

instrumentation/opentelemetry-api/opentelemetry-api-1.10/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_10/metrics/ApplicationLongGaugeBuilder.java

@@ -11,11 +11,12 @@ import application.io.opentelemetry.api.metrics.ObservableLongMeasurement;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.util.function.Consumer;
 
-final class ApplicationLongGaugeBuilder implements LongGaugeBuilder {
+public class ApplicationLongGaugeBuilder implements LongGaugeBuilder {
 
   private final io.opentelemetry.api.metrics.LongGaugeBuilder agentBuilder;
 
-  ApplicationLongGaugeBuilder(io.opentelemetry.api.metrics.LongGaugeBuilder agentBuilder) {
+  protected ApplicationLongGaugeBuilder(
+      io.opentelemetry.api.metrics.LongGaugeBuilder agentBuilder) {
     this.agentBuilder = agentBuilder;
   }
 

instrumentation/opentelemetry-api/opentelemetry-api-1.10/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_10/metrics/ApplicationLongHistogramBuilder.java

@@ -9,11 +9,12 @@ import application.io.opentelemetry.api.metrics.LongHistogram;
 import application.io.opentelemetry.api.metrics.LongHistogramBuilder;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 
-final class ApplicationLongHistogramBuilder implements LongHistogramBuilder {
+public class ApplicationLongHistogramBuilder implements LongHistogramBuilder {
 
   private final io.opentelemetry.api.metrics.LongHistogramBuilder agentBuilder;
 
-  ApplicationLongHistogramBuilder(io.opentelemetry.api.metrics.LongHistogramBuilder agentBuilder) {
+  protected ApplicationLongHistogramBuilder(
+      io.opentelemetry.api.metrics.LongHistogramBuilder agentBuilder) {
     this.agentBuilder = agentBuilder;
   }
 

instrumentation/opentelemetry-api/opentelemetry-api-1.10/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_10/metrics/ApplicationLongUpDownCounterBuilder.java

@@ -13,11 +13,11 @@ import application.io.opentelemetry.api.metrics.ObservableLongUpDownCounter;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import java.util.function.Consumer;
 
-final class ApplicationLongUpDownCounterBuilder implements LongUpDownCounterBuilder {
+public class ApplicationLongUpDownCounterBuilder implements LongUpDownCounterBuilder {
 
   private final io.opentelemetry.api.metrics.LongUpDownCounterBuilder agentBuilder;
 
-  ApplicationLongUpDownCounterBuilder(
+  protected ApplicationLongUpDownCounterBuilder(
       io.opentelemetry.api.metrics.LongUpDownCounterBuilder agentBuilder) {
     this.agentBuilder = agentBuilder;
   }

instrumentation/opentelemetry-api/opentelemetry-api-1.15/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_15/metrics/ApplicationMeter115.java

@@ -10,11 +10,11 @@ import application.io.opentelemetry.api.metrics.ObservableMeasurement;
 import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationMeter;
 import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ObservableMeasurementWrapper;
 
-class ApplicationMeter115 extends ApplicationMeter {
+public class ApplicationMeter115 extends ApplicationMeter {
 
   private final io.opentelemetry.api.metrics.Meter agentMeter;
 
-  ApplicationMeter115(io.opentelemetry.api.metrics.Meter agentMeter) {
+  protected ApplicationMeter115(io.opentelemetry.api.metrics.Meter agentMeter) {
     super(agentMeter);
     this.agentMeter = agentMeter;
   }

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

@@ -11,10 +11,12 @@ import application.io.opentelemetry.api.metrics.MeterProvider;
 import application.io.opentelemetry.api.trace.TracerProvider;
 import application.io.opentelemetry.context.propagation.ContextPropagators;
 import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.context.propagation.ApplicationContextPropagators;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationMeterFactory;
 import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationMeterProvider;
 import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_15.metrics.ApplicationMeterFactory115;
 import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_27.logs.ApplicationLoggerProvider;
 import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_4.trace.ApplicationTracerProvider14;
+import java.lang.reflect.InvocationTargetException;
 
 public final class ApplicationOpenTelemetry127 implements OpenTelemetry {
 
@@ -36,8 +38,7 @@ public final class ApplicationOpenTelemetry127 implements OpenTelemetry {
     applicationContextPropagators =
         new ApplicationContextPropagators(agentOpenTelemetry.getPropagators());
     applicationMeterProvider =
-        new ApplicationMeterProvider(
-            new ApplicationMeterFactory115(), agentOpenTelemetry.getMeterProvider());
+        new ApplicationMeterProvider(getMeterFactory(), agentOpenTelemetry.getMeterProvider());
     applicationLoggerProvider = new ApplicationLoggerProvider(agentOpenTelemetry.getLogsBridge());
   }
 
@@ -60,4 +61,20 @@ public final class ApplicationOpenTelemetry127 implements OpenTelemetry {
   public ContextPropagators getPropagators() {
     return applicationContextPropagators;
   }
+
+  private static ApplicationMeterFactory getMeterFactory() {
+    try {
+      // this class is defined in opentelemetry-api-1.31
+      Class<?> clazz =
+          Class.forName(
+              "io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics.ApplicationMeterFactory131");
+      return (ApplicationMeterFactory) clazz.getConstructor().newInstance();
+    } catch (ClassNotFoundException
+        | NoSuchMethodException
+        | InstantiationException
+        | IllegalAccessException
+        | InvocationTargetException exception) {
+      return new ApplicationMeterFactory115();
+    }
+  }
 }

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

@@ -0,0 +1,16 @@
+plugins {
+  id("otel.javaagent-instrumentation")
+}
+
+dependencies {
+  compileOnly(project(":opentelemetry-api-shaded-for-instrumenting", configuration = "v1_31"))
+  compileOnly("io.opentelemetry:opentelemetry-extension-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"))
+
+  testImplementation("io.opentelemetry:opentelemetry-extension-incubator")
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/OpenTelemetryApiInstrumentationModule.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31;
+
+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 java.util.List;
+
+@AutoService(InstrumentationModule.class)
+public class OpenTelemetryApiInstrumentationModule extends InstrumentationModule {
+  public OpenTelemetryApiInstrumentationModule() {
+    super("opentelemetry-api", "opentelemetry-api-1.31");
+  }
+
+  @Override
+  public boolean isIndyModule() {
+    return false;
+  }
+
+  @Override
+  public List<TypeInstrumentation> typeInstrumentations() {
+    return singletonList(new OpenTelemetryInstrumentation());
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/OpenTelemetryInstrumentation.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31;
+
+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_31.metrics.ApplicationMeterFactory131;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+public class OpenTelemetryInstrumentation implements TypeInstrumentation {
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return named("application.io.opentelemetry.api.GlobalOpenTelemetry");
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        none(), OpenTelemetryInstrumentation.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 ApplicationMeterFactory131 is recognized
+      // as helper class and injected into class loader
+      ApplicationMeterFactory131.class.getName();
+    }
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationDoubleCounterBuilder131.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.common.AttributeKey;
+import application.io.opentelemetry.extension.incubator.metrics.ExtendedDoubleCounterBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.Bridging;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationDoubleCounterBuilder;
+import java.util.List;
+
+final class ApplicationDoubleCounterBuilder131 extends ApplicationDoubleCounterBuilder
+    implements ExtendedDoubleCounterBuilder {
+
+  private final io.opentelemetry.api.metrics.DoubleCounterBuilder agentBuilder;
+
+  ApplicationDoubleCounterBuilder131(
+      io.opentelemetry.api.metrics.DoubleCounterBuilder agentBuilder) {
+    super(agentBuilder);
+    this.agentBuilder = agentBuilder;
+  }
+
+  @Override
+  public ExtendedDoubleCounterBuilder setAttributesAdvice(List<AttributeKey<?>> attributes) {
+    ((io.opentelemetry.extension.incubator.metrics.ExtendedDoubleCounterBuilder) agentBuilder)
+        .setAttributesAdvice(Bridging.toAgent(attributes));
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationDoubleGaugeBuilder131.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.common.AttributeKey;
+import application.io.opentelemetry.api.common.Attributes;
+import application.io.opentelemetry.api.metrics.LongGaugeBuilder;
+import application.io.opentelemetry.extension.incubator.metrics.DoubleGauge;
+import application.io.opentelemetry.extension.incubator.metrics.ExtendedDoubleGaugeBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.Bridging;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationDoubleGaugeBuilder;
+import java.util.List;
+
+final class ApplicationDoubleGaugeBuilder131 extends ApplicationDoubleGaugeBuilder
+    implements ExtendedDoubleGaugeBuilder {
+
+  private final io.opentelemetry.api.metrics.DoubleGaugeBuilder agentBuilder;
+
+  ApplicationDoubleGaugeBuilder131(io.opentelemetry.api.metrics.DoubleGaugeBuilder agentBuilder) {
+    super(agentBuilder);
+    this.agentBuilder = agentBuilder;
+  }
+
+  @Override
+  public LongGaugeBuilder ofLongs() {
+    return new ApplicationLongGaugeBuilder131(agentBuilder.ofLongs());
+  }
+
+  @Override
+  public DoubleGauge build() {
+    io.opentelemetry.extension.incubator.metrics.DoubleGauge agentDoubleGauge =
+        ((io.opentelemetry.extension.incubator.metrics.ExtendedDoubleGaugeBuilder) agentBuilder)
+            .build();
+    return new DoubleGauge() {
+
+      @Override
+      public void set(double value) {
+        agentDoubleGauge.set(value);
+      }
+
+      @Override
+      public void set(double value, Attributes attributes) {
+        agentDoubleGauge.set(value, Bridging.toAgent(attributes));
+      }
+    };
+  }
+
+  @Override
+  public ExtendedDoubleGaugeBuilder setAttributesAdvice(List<AttributeKey<?>> attributes) {
+    ((io.opentelemetry.extension.incubator.metrics.ExtendedDoubleGaugeBuilder) agentBuilder)
+        .setAttributesAdvice(Bridging.toAgent(attributes));
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationDoubleHistogramBuilder131.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.common.AttributeKey;
+import application.io.opentelemetry.api.metrics.LongHistogramBuilder;
+import application.io.opentelemetry.extension.incubator.metrics.ExtendedDoubleHistogramBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.Bridging;
+import java.util.List;
+
+final class ApplicationDoubleHistogramBuilder131 extends ApplicationDoubleHistogramBuilder132
+    implements ExtendedDoubleHistogramBuilder {
+
+  private final io.opentelemetry.api.metrics.DoubleHistogramBuilder agentBuilder;
+
+  ApplicationDoubleHistogramBuilder131(
+      io.opentelemetry.api.metrics.DoubleHistogramBuilder agentBuilder) {
+    super(agentBuilder);
+    this.agentBuilder = agentBuilder;
+  }
+
+  @Override
+  public LongHistogramBuilder ofLongs() {
+    return new ApplicationLongHistogramBuilder131(agentBuilder.ofLongs());
+  }
+
+  @Override
+  public ExtendedDoubleHistogramBuilder setExplicitBucketBoundariesAdvice(
+      List<Double> bucketBoundaries) {
+    agentBuilder.setExplicitBucketBoundariesAdvice(bucketBoundaries);
+    return this;
+  }
+
+  @Override
+  public ExtendedDoubleHistogramBuilder setAttributesAdvice(List<AttributeKey<?>> attributes) {
+    ((io.opentelemetry.extension.incubator.metrics.ExtendedDoubleHistogramBuilder) agentBuilder)
+        .setAttributesAdvice(Bridging.toAgent(attributes));
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationDoubleHistogramBuilder132.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.metrics.DoubleHistogramBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationDoubleHistogramBuilder;
+import java.util.List;
+
+class ApplicationDoubleHistogramBuilder132 extends ApplicationDoubleHistogramBuilder {
+
+  private final io.opentelemetry.api.metrics.DoubleHistogramBuilder agentBuilder;
+
+  ApplicationDoubleHistogramBuilder132(
+      io.opentelemetry.api.metrics.DoubleHistogramBuilder agentBuilder) {
+    super(agentBuilder);
+    this.agentBuilder = agentBuilder;
+  }
+
+  // return type is different from what 1.31 uses
+  public DoubleHistogramBuilder setExplicitBucketBoundariesAdvice(List<Double> bucketBoundaries) {
+    agentBuilder.setExplicitBucketBoundariesAdvice(bucketBoundaries);
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationDoubleUpDownCounterBuilder131.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.common.AttributeKey;
+import application.io.opentelemetry.extension.incubator.metrics.ExtendedDoubleUpDownCounterBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.Bridging;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationDoubleUpDownCounterBuilder;
+import java.util.List;
+
+final class ApplicationDoubleUpDownCounterBuilder131 extends ApplicationDoubleUpDownCounterBuilder
+    implements ExtendedDoubleUpDownCounterBuilder {
+
+  private final io.opentelemetry.api.metrics.DoubleUpDownCounterBuilder agentBuilder;
+
+  ApplicationDoubleUpDownCounterBuilder131(
+      io.opentelemetry.api.metrics.DoubleUpDownCounterBuilder agentBuilder) {
+    super(agentBuilder);
+    this.agentBuilder = agentBuilder;
+  }
+
+  @Override
+  public ExtendedDoubleUpDownCounterBuilder setAttributesAdvice(List<AttributeKey<?>> attributes) {
+    ((io.opentelemetry.extension.incubator.metrics.ExtendedDoubleUpDownCounterBuilder) agentBuilder)
+        .setAttributesAdvice(Bridging.toAgent(attributes));
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationLongCounterBuilder131.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.common.AttributeKey;
+import application.io.opentelemetry.api.metrics.DoubleCounterBuilder;
+import application.io.opentelemetry.extension.incubator.metrics.ExtendedLongCounterBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.Bridging;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationLongCounterBuilder;
+import java.util.List;
+
+final class ApplicationLongCounterBuilder131 extends ApplicationLongCounterBuilder
+    implements ExtendedLongCounterBuilder {
+
+  private final io.opentelemetry.api.metrics.LongCounterBuilder agentBuilder;
+
+  ApplicationLongCounterBuilder131(io.opentelemetry.api.metrics.LongCounterBuilder agentBuilder) {
+    super(agentBuilder);
+    this.agentBuilder = agentBuilder;
+  }
+
+  @Override
+  public DoubleCounterBuilder ofDoubles() {
+    return new ApplicationDoubleCounterBuilder131(agentBuilder.ofDoubles());
+  }
+
+  @Override
+  public ExtendedLongCounterBuilder setAttributesAdvice(List<AttributeKey<?>> attributes) {
+    ((io.opentelemetry.extension.incubator.metrics.ExtendedLongCounterBuilder) agentBuilder)
+        .setAttributesAdvice(Bridging.toAgent(attributes));
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationLongGaugeBuilder131.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.common.AttributeKey;
+import application.io.opentelemetry.api.common.Attributes;
+import application.io.opentelemetry.extension.incubator.metrics.ExtendedLongGaugeBuilder;
+import application.io.opentelemetry.extension.incubator.metrics.LongGauge;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.Bridging;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationLongGaugeBuilder;
+import java.util.List;
+
+final class ApplicationLongGaugeBuilder131 extends ApplicationLongGaugeBuilder
+    implements ExtendedLongGaugeBuilder {
+
+  private final io.opentelemetry.api.metrics.LongGaugeBuilder agentBuilder;
+
+  ApplicationLongGaugeBuilder131(io.opentelemetry.api.metrics.LongGaugeBuilder agentBuilder) {
+    super(agentBuilder);
+    this.agentBuilder = agentBuilder;
+  }
+
+  @Override
+  public LongGauge build() {
+    io.opentelemetry.extension.incubator.metrics.LongGauge agentLongGauge =
+        ((io.opentelemetry.extension.incubator.metrics.ExtendedLongGaugeBuilder) agentBuilder)
+            .build();
+    return new LongGauge() {
+      @Override
+      public void set(long value) {
+        agentLongGauge.set(value);
+      }
+
+      @Override
+      public void set(long value, Attributes attributes) {
+        agentLongGauge.set(value, Bridging.toAgent(attributes));
+      }
+    };
+  }
+
+  @Override
+  public ExtendedLongGaugeBuilder setAttributesAdvice(List<AttributeKey<?>> attributes) {
+    ((io.opentelemetry.extension.incubator.metrics.ExtendedLongGaugeBuilder) agentBuilder)
+        .setAttributesAdvice(Bridging.toAgent(attributes));
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationLongHistogramBuilder131.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.common.AttributeKey;
+import application.io.opentelemetry.extension.incubator.metrics.ExtendedLongHistogramBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.Bridging;
+import java.util.List;
+
+final class ApplicationLongHistogramBuilder131 extends ApplicationLongHistogramBuilder132
+    implements ExtendedLongHistogramBuilder {
+
+  private final io.opentelemetry.api.metrics.LongHistogramBuilder agentBuilder;
+
+  ApplicationLongHistogramBuilder131(
+      io.opentelemetry.api.metrics.LongHistogramBuilder agentBuilder) {
+    super(agentBuilder);
+    this.agentBuilder = agentBuilder;
+  }
+
+  @Override
+  public ExtendedLongHistogramBuilder setExplicitBucketBoundariesAdvice(
+      List<Long> bucketBoundaries) {
+    agentBuilder.setExplicitBucketBoundariesAdvice(bucketBoundaries);
+    return this;
+  }
+
+  @Override
+  public ExtendedLongHistogramBuilder setAttributesAdvice(List<AttributeKey<?>> attributes) {
+    ((io.opentelemetry.extension.incubator.metrics.ExtendedLongHistogramBuilder) agentBuilder)
+        .setAttributesAdvice(Bridging.toAgent(attributes));
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationLongHistogramBuilder132.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.metrics.LongHistogramBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationLongHistogramBuilder;
+import java.util.List;
+
+class ApplicationLongHistogramBuilder132 extends ApplicationLongHistogramBuilder {
+
+  private final io.opentelemetry.api.metrics.LongHistogramBuilder agentBuilder;
+
+  ApplicationLongHistogramBuilder132(
+      io.opentelemetry.api.metrics.LongHistogramBuilder agentBuilder) {
+    super(agentBuilder);
+    this.agentBuilder = agentBuilder;
+  }
+
+  // return type is different from what 1.31 uses
+  public LongHistogramBuilder setExplicitBucketBoundariesAdvice(List<Long> bucketBoundaries) {
+    agentBuilder.setExplicitBucketBoundariesAdvice(bucketBoundaries);
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationLongUpDownCounterBuilder131.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.common.AttributeKey;
+import application.io.opentelemetry.api.metrics.DoubleUpDownCounterBuilder;
+import application.io.opentelemetry.extension.incubator.metrics.ExtendedLongUpDownCounterBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.trace.Bridging;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationLongUpDownCounterBuilder;
+import java.util.List;
+
+final class ApplicationLongUpDownCounterBuilder131 extends ApplicationLongUpDownCounterBuilder
+    implements ExtendedLongUpDownCounterBuilder {
+
+  private final io.opentelemetry.api.metrics.LongUpDownCounterBuilder agentBuilder;
+
+  ApplicationLongUpDownCounterBuilder131(
+      io.opentelemetry.api.metrics.LongUpDownCounterBuilder agentBuilder) {
+    super(agentBuilder);
+    this.agentBuilder = agentBuilder;
+  }
+
+  @Override
+  public DoubleUpDownCounterBuilder ofDoubles() {
+    return new ApplicationDoubleUpDownCounterBuilder131(agentBuilder.ofDoubles());
+  }
+
+  @Override
+  public ExtendedLongUpDownCounterBuilder setAttributesAdvice(List<AttributeKey<?>> attributes) {
+    ((io.opentelemetry.extension.incubator.metrics.ExtendedLongUpDownCounterBuilder) agentBuilder)
+        .setAttributesAdvice(Bridging.toAgent(attributes));
+    return this;
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationMeter131.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import application.io.opentelemetry.api.metrics.DoubleGaugeBuilder;
+import application.io.opentelemetry.api.metrics.DoubleHistogramBuilder;
+import application.io.opentelemetry.api.metrics.LongCounterBuilder;
+import application.io.opentelemetry.api.metrics.LongUpDownCounterBuilder;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_15.metrics.ApplicationMeter115;
+
+class ApplicationMeter131 extends ApplicationMeter115 {
+
+  private final io.opentelemetry.api.metrics.Meter agentMeter;
+
+  ApplicationMeter131(io.opentelemetry.api.metrics.Meter agentMeter) {
+    super(agentMeter);
+    this.agentMeter = agentMeter;
+  }
+
+  @Override
+  public LongCounterBuilder counterBuilder(String name) {
+    return new ApplicationLongCounterBuilder131(agentMeter.counterBuilder(name));
+  }
+
+  @Override
+  public LongUpDownCounterBuilder upDownCounterBuilder(String name) {
+    return new ApplicationLongUpDownCounterBuilder131(agentMeter.upDownCounterBuilder(name));
+  }
+
+  @Override
+  public DoubleHistogramBuilder histogramBuilder(String name) {
+    return new ApplicationDoubleHistogramBuilder131(agentMeter.histogramBuilder(name));
+  }
+
+  @Override
+  public DoubleGaugeBuilder gaugeBuilder(String name) {
+    return new ApplicationDoubleGaugeBuilder131(agentMeter.gaugeBuilder(name));
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/ApplicationMeterFactory131.java

@@ -0,0 +1,18 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationMeter;
+import io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics.ApplicationMeterFactory;
+
+// this class is used from opentelemetry-api-1.27 via reflection
+public final class ApplicationMeterFactory131 implements ApplicationMeterFactory {
+  @Override
+  public ApplicationMeter newMeter(Meter agentMeter) {
+    return new ApplicationMeter131(agentMeter);
+  }
+}

instrumentation/opentelemetry-api/opentelemetry-api-1.31/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_31/metrics/MeterTest.java

@@ -0,0 +1,468 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_31.metrics;
+
+import static io.opentelemetry.api.common.AttributeKey.stringKey;
+import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
+import static java.util.Collections.singletonList;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.metrics.DoubleCounter;
+import io.opentelemetry.api.metrics.DoubleCounterBuilder;
+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.DoubleUpDownCounterBuilder;
+import io.opentelemetry.api.metrics.LongCounter;
+import io.opentelemetry.api.metrics.LongCounterBuilder;
+import io.opentelemetry.api.metrics.LongGaugeBuilder;
+import io.opentelemetry.api.metrics.LongHistogram;
+import io.opentelemetry.api.metrics.LongHistogramBuilder;
+import io.opentelemetry.api.metrics.LongUpDownCounter;
+import io.opentelemetry.api.metrics.LongUpDownCounterBuilder;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.api.metrics.ObservableDoubleGauge;
+import io.opentelemetry.api.metrics.ObservableLongGauge;
+import io.opentelemetry.extension.incubator.metrics.DoubleGauge;
+import io.opentelemetry.extension.incubator.metrics.ExtendedDoubleCounterBuilder;
+import io.opentelemetry.extension.incubator.metrics.ExtendedDoubleGaugeBuilder;
+import io.opentelemetry.extension.incubator.metrics.ExtendedDoubleHistogramBuilder;
+import io.opentelemetry.extension.incubator.metrics.ExtendedDoubleUpDownCounterBuilder;
+import io.opentelemetry.extension.incubator.metrics.ExtendedLongCounterBuilder;
+import io.opentelemetry.extension.incubator.metrics.ExtendedLongGaugeBuilder;
+import io.opentelemetry.extension.incubator.metrics.ExtendedLongHistogramBuilder;
+import io.opentelemetry.extension.incubator.metrics.ExtendedLongUpDownCounterBuilder;
+import io.opentelemetry.extension.incubator.metrics.LongGauge;
+import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
+import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
+import io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions;
+import org.assertj.core.api.AbstractIterableAssert;
+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;
+
+class MeterTest {
+
+  @RegisterExtension
+  static final AgentInstrumentationExtension testing = AgentInstrumentationExtension.create();
+
+  private String instrumentationName;
+  private Meter meter;
+
+  @BeforeEach
+  void setupMeter(TestInfo test) {
+    instrumentationName = "test-" + test.getDisplayName();
+    meter =
+        testing
+            .getOpenTelemetry()
+            .getMeterProvider()
+            .meterBuilder(instrumentationName)
+            .setInstrumentationVersion("1.2.3")
+            .setSchemaUrl("http://schema.org")
+            .build();
+  }
+
+  @Test
+  void longCounter() {
+    LongCounterBuilder builder = meter.counterBuilder("test").setDescription("d").setUnit("u");
+    assertThat(builder).isInstanceOf(ExtendedLongCounterBuilder.class);
+    ExtendedLongCounterBuilder extendedBuilder = (ExtendedLongCounterBuilder) builder;
+    extendedBuilder.setAttributesAdvice(singletonList(stringKey("test")));
+
+    LongCounter instrument = builder.build();
+
+    instrument.add(5, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+    instrument.add(6, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+
+    testing.waitAndAssertMetrics(
+        instrumentationName,
+        "test",
+        metrics ->
+            metrics.anySatisfy(
+                metric ->
+                    OpenTelemetryAssertions.assertThat(metric)
+                        .hasDescription("d")
+                        .hasUnit("u")
+                        .hasInstrumentationScope(
+                            InstrumentationScopeInfo.builder(instrumentationName)
+                                .setVersion("1.2.3")
+                                .build())
+                        .hasLongSumSatisfying(
+                            sum ->
+                                sum.isMonotonic()
+                                    .hasPointsSatisfying(
+                                        point ->
+                                            point
+                                                .hasValue(11)
+                                                .hasAttributesSatisfying(
+                                                    equalTo(stringKey("test"), "test"))))));
+  }
+
+  @Test
+  void doubleCounter() {
+    DoubleCounterBuilder builder =
+        meter.counterBuilder("test").ofDoubles().setDescription("d").setUnit("u");
+    assertThat(builder).isInstanceOf(ExtendedDoubleCounterBuilder.class);
+    ExtendedDoubleCounterBuilder extendedBuilder = (ExtendedDoubleCounterBuilder) builder;
+    extendedBuilder.setAttributesAdvice(singletonList(stringKey("test")));
+
+    DoubleCounter instrument = builder.build();
+
+    instrument.add(5.5, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+    instrument.add(6.6, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+
+    testing.waitAndAssertMetrics(
+        instrumentationName,
+        "test",
+        metrics ->
+            metrics.anySatisfy(
+                metric ->
+                    OpenTelemetryAssertions.assertThat(metric)
+                        .hasDescription("d")
+                        .hasUnit("u")
+                        .hasInstrumentationScope(
+                            InstrumentationScopeInfo.builder(instrumentationName)
+                                .setVersion("1.2.3")
+                                .build())
+                        .hasDoubleSumSatisfying(
+                            sum ->
+                                sum.isMonotonic()
+                                    .hasPointsSatisfying(
+                                        point ->
+                                            point
+                                                .hasValue(12.1)
+                                                .hasAttributesSatisfying(
+                                                    equalTo(stringKey("test"), "test"))))));
+  }
+
+  @Test
+  void longUpDownCounter() {
+    LongUpDownCounterBuilder builder =
+        meter.upDownCounterBuilder("test").setDescription("d").setUnit("u");
+    assertThat(builder).isInstanceOf(ExtendedLongUpDownCounterBuilder.class);
+    ExtendedLongUpDownCounterBuilder extendedBuilder = (ExtendedLongUpDownCounterBuilder) builder;
+    extendedBuilder.setAttributesAdvice(singletonList(stringKey("test")));
+
+    LongUpDownCounter instrument = builder.build();
+
+    instrument.add(5, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+    instrument.add(6, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+
+    testing.waitAndAssertMetrics(
+        instrumentationName,
+        "test",
+        metrics ->
+            metrics.anySatisfy(
+                metric ->
+                    OpenTelemetryAssertions.assertThat(metric)
+                        .hasDescription("d")
+                        .hasUnit("u")
+                        .hasInstrumentationScope(
+                            InstrumentationScopeInfo.builder(instrumentationName)
+                                .setVersion("1.2.3")
+                                .build())
+                        .hasLongSumSatisfying(
+                            sum ->
+                                sum.isNotMonotonic()
+                                    .hasPointsSatisfying(
+                                        point ->
+                                            point
+                                                .hasValue(11)
+                                                .hasAttributesSatisfying(
+                                                    equalTo(stringKey("test"), "test"))))));
+  }
+
+  @Test
+  void doubleUpDownCounter() {
+    DoubleUpDownCounterBuilder builder =
+        meter.upDownCounterBuilder("test").ofDoubles().setDescription("d").setUnit("u");
+    assertThat(builder).isInstanceOf(ExtendedDoubleUpDownCounterBuilder.class);
+    ExtendedDoubleUpDownCounterBuilder extendedBuilder =
+        (ExtendedDoubleUpDownCounterBuilder) builder;
+    extendedBuilder.setAttributesAdvice(singletonList(stringKey("test")));
+
+    DoubleUpDownCounter instrument = builder.build();
+
+    instrument.add(5.5, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+    instrument.add(6.6, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+
+    testing.waitAndAssertMetrics(
+        instrumentationName,
+        "test",
+        metrics ->
+            metrics.anySatisfy(
+                metric ->
+                    OpenTelemetryAssertions.assertThat(metric)
+                        .hasDescription("d")
+                        .hasUnit("u")
+                        .hasInstrumentationScope(
+                            InstrumentationScopeInfo.builder(instrumentationName)
+                                .setVersion("1.2.3")
+                                .build())
+                        .hasDoubleSumSatisfying(
+                            sum ->
+                                sum.isNotMonotonic()
+                                    .hasPointsSatisfying(
+                                        point ->
+                                            point
+                                                .hasValue(12.1)
+                                                .hasAttributesSatisfying(
+                                                    equalTo(stringKey("test"), "test"))))));
+  }
+
+  @Test
+  void longHistogram() {
+    LongHistogramBuilder builder =
+        meter.histogramBuilder("test").ofLongs().setDescription("d").setUnit("u");
+    assertThat(builder).isInstanceOf(ExtendedLongHistogramBuilder.class);
+    ExtendedLongHistogramBuilder extendedBuilder = (ExtendedLongHistogramBuilder) builder;
+    extendedBuilder.setAttributesAdvice(singletonList(stringKey("test")));
+    extendedBuilder.setExplicitBucketBoundariesAdvice(singletonList(10L));
+
+    LongHistogram instrument = builder.build();
+
+    instrument.record(5, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+    instrument.record(6, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+
+    testing.waitAndAssertMetrics(
+        instrumentationName,
+        "test",
+        metrics ->
+            metrics.anySatisfy(
+                metric ->
+                    OpenTelemetryAssertions.assertThat(metric)
+                        .hasDescription("d")
+                        .hasUnit("u")
+                        .hasInstrumentationScope(
+                            InstrumentationScopeInfo.builder(instrumentationName)
+                                .setVersion("1.2.3")
+                                .build())
+                        .hasHistogramSatisfying(
+                            histogram ->
+                                histogram.hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasSum(11.0)
+                                            .hasBucketBoundaries(10.0)
+                                            .hasAttributesSatisfying(
+                                                equalTo(stringKey("test"), "test"))))));
+  }
+
+  @Test
+  void doubleHistogram() {
+    DoubleHistogramBuilder builder =
+        meter.histogramBuilder("test").setDescription("d").setUnit("u");
+    assertThat(builder).isInstanceOf(ExtendedDoubleHistogramBuilder.class);
+    ExtendedDoubleHistogramBuilder extendedBuilder = (ExtendedDoubleHistogramBuilder) builder;
+    extendedBuilder.setAttributesAdvice(singletonList(stringKey("test")));
+    extendedBuilder.setExplicitBucketBoundariesAdvice(singletonList(10.0));
+
+    DoubleHistogram instrument = builder.build();
+
+    instrument.record(5.5, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+    instrument.record(6.6, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+
+    testing.waitAndAssertMetrics(
+        instrumentationName,
+        "test",
+        metrics ->
+            metrics.anySatisfy(
+                metric ->
+                    OpenTelemetryAssertions.assertThat(metric)
+                        .hasDescription("d")
+                        .hasUnit("u")
+                        .hasInstrumentationScope(
+                            InstrumentationScopeInfo.builder(instrumentationName)
+                                .setVersion("1.2.3")
+                                .build())
+                        .hasHistogramSatisfying(
+                            histogram ->
+                                histogram.hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasSum(12.1)
+                                            .hasBucketBoundaries(10.0)
+                                            .hasAttributesSatisfying(
+                                                equalTo(stringKey("test"), "test"))))));
+  }
+
+  @Test
+  void longGauge() throws InterruptedException {
+    LongGaugeBuilder builder =
+        meter.gaugeBuilder("test").ofLongs().setDescription("d").setUnit("u");
+    assertThat(builder).isInstanceOf(ExtendedLongGaugeBuilder.class);
+    ExtendedLongGaugeBuilder extendedBuilder = (ExtendedLongGaugeBuilder) builder;
+    extendedBuilder.setAttributesAdvice(singletonList(stringKey("test")));
+
+    ObservableLongGauge observableGauge =
+        builder.buildWithCallback(
+            result ->
+                result.record(123, Attributes.of(stringKey("test"), "test", stringKey("q"), "r")));
+
+    testing.waitAndAssertMetrics(
+        instrumentationName,
+        "test",
+        metrics ->
+            metrics.anySatisfy(
+                metric ->
+                    OpenTelemetryAssertions.assertThat(metric)
+                        .hasDescription("d")
+                        .hasUnit("u")
+                        .hasInstrumentationScope(
+                            InstrumentationScopeInfo.builder(instrumentationName)
+                                .setVersion("1.2.3")
+                                .build())
+                        .hasLongGaugeSatisfying(
+                            gauge ->
+                                gauge.hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasValue(123)
+                                            .hasAttributesSatisfying(
+                                                equalTo(stringKey("test"), "test"))))));
+
+    observableGauge.close();
+
+    // sleep exporter interval
+    Thread.sleep(100);
+    testing.clearData();
+    Thread.sleep(100);
+
+    testing.waitAndAssertMetrics(instrumentationName, "test", AbstractIterableAssert::isEmpty);
+  }
+
+  @Test
+  void syncLongGauge() throws InterruptedException {
+    LongGaugeBuilder builder =
+        meter.gaugeBuilder("test").ofLongs().setDescription("d").setUnit("u");
+    assertThat(builder).isInstanceOf(ExtendedLongGaugeBuilder.class);
+    ExtendedLongGaugeBuilder extendedBuilder = (ExtendedLongGaugeBuilder) builder;
+    extendedBuilder.setAttributesAdvice(singletonList(stringKey("test")));
+
+    LongGauge longGauge = extendedBuilder.build();
+    longGauge.set(321);
+    longGauge.set(123, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+
+    testing.waitAndAssertMetrics(
+        instrumentationName,
+        "test",
+        metrics ->
+            metrics.anySatisfy(
+                metric ->
+                    OpenTelemetryAssertions.assertThat(metric)
+                        .hasDescription("d")
+                        .hasUnit("u")
+                        .hasInstrumentationScope(
+                            InstrumentationScopeInfo.builder(instrumentationName)
+                                .setVersion("1.2.3")
+                                .build())
+                        .hasLongGaugeSatisfying(
+                            gauge ->
+                                gauge.hasPointsSatisfying(
+                                    point -> point.hasValue(321).hasAttributes(Attributes.empty()),
+                                    point ->
+                                        point
+                                            .hasValue(123)
+                                            .hasAttributesSatisfying(
+                                                equalTo(stringKey("test"), "test"))))));
+
+    // sleep exporter interval
+    Thread.sleep(100);
+    testing.clearData();
+    Thread.sleep(100);
+
+    testing.waitAndAssertMetrics(instrumentationName, "test", AbstractIterableAssert::isEmpty);
+  }
+
+  @Test
+  void doubleGauge() throws InterruptedException {
+    DoubleGaugeBuilder builder = meter.gaugeBuilder("test").setDescription("d").setUnit("u");
+    assertThat(builder).isInstanceOf(ExtendedDoubleGaugeBuilder.class);
+    ExtendedDoubleGaugeBuilder extendedBuilder = (ExtendedDoubleGaugeBuilder) builder;
+    extendedBuilder.setAttributesAdvice(singletonList(stringKey("test")));
+
+    ObservableDoubleGauge observableGauge =
+        builder.buildWithCallback(
+            result ->
+                result.record(1.23, Attributes.of(stringKey("test"), "test", stringKey("q"), "r")));
+
+    testing.waitAndAssertMetrics(
+        instrumentationName,
+        "test",
+        metrics ->
+            metrics.anySatisfy(
+                metric ->
+                    OpenTelemetryAssertions.assertThat(metric)
+                        .hasDescription("d")
+                        .hasUnit("u")
+                        .hasInstrumentationScope(
+                            InstrumentationScopeInfo.builder(instrumentationName)
+                                .setVersion("1.2.3")
+                                .build())
+                        .hasDoubleGaugeSatisfying(
+                            gauge ->
+                                gauge.hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasValue(1.23)
+                                            .hasAttributesSatisfying(
+                                                equalTo(stringKey("test"), "test"))))));
+
+    observableGauge.close();
+
+    // sleep exporter interval
+    Thread.sleep(100);
+    testing.clearData();
+    Thread.sleep(100);
+
+    testing.waitAndAssertMetrics(instrumentationName, "test", AbstractIterableAssert::isEmpty);
+  }
+
+  @Test
+  void syncDoubleGauge() throws InterruptedException {
+    DoubleGaugeBuilder builder = meter.gaugeBuilder("test").setDescription("d").setUnit("u");
+    assertThat(builder).isInstanceOf(ExtendedDoubleGaugeBuilder.class);
+    ExtendedDoubleGaugeBuilder extendedBuilder = (ExtendedDoubleGaugeBuilder) builder;
+    extendedBuilder.setAttributesAdvice(singletonList(stringKey("test")));
+
+    DoubleGauge doubleGauge = extendedBuilder.build();
+    doubleGauge.set(3.21);
+    doubleGauge.set(1.23, Attributes.of(stringKey("test"), "test", stringKey("q"), "r"));
+
+    testing.waitAndAssertMetrics(
+        instrumentationName,
+        "test",
+        metrics ->
+            metrics.anySatisfy(
+                metric ->
+                    OpenTelemetryAssertions.assertThat(metric)
+                        .hasDescription("d")
+                        .hasUnit("u")
+                        .hasInstrumentationScope(
+                            InstrumentationScopeInfo.builder(instrumentationName)
+                                .setVersion("1.2.3")
+                                .build())
+                        .hasDoubleGaugeSatisfying(
+                            gauge ->
+                                gauge.hasPointsSatisfying(
+                                    point -> point.hasValue(3.21).hasAttributes(Attributes.empty()),
+                                    point ->
+                                        point
+                                            .hasValue(1.23)
+                                            .hasAttributesSatisfying(
+                                                equalTo(stringKey("test"), "test"))))));
+
+    // sleep exporter interval
+    Thread.sleep(100);
+    testing.clearData();
+    Thread.sleep(100);
+
+    testing.waitAndAssertMetrics(instrumentationName, "test", AbstractIterableAssert::isEmpty);
+  }
+}

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

@@ -31,6 +31,13 @@ val v1_27Deps by configurations.creating {
   // exclude the bom added by dependencyManagement
   exclude("io.opentelemetry", "opentelemetry-bom")
 }
+val v1_31Deps 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 {
@@ -45,6 +52,10 @@ val v1_27 by configurations.creating {
   isCanBeConsumed = true
   isCanBeResolved = false
 }
+val v1_31 by configurations.creating {
+  isCanBeConsumed = true
+  isCanBeResolved = false
+}
 
 dependencies {
   latestDeps("io.opentelemetry:opentelemetry-api")
@@ -65,6 +76,19 @@ dependencies {
         strictly("1.27.0")
       }
     }
+    v1_31Deps("io.opentelemetry:$it") {
+      version {
+        strictly("1.31.0")
+      }
+    }
+  }
+
+  listOf("opentelemetry-extension-incubator").forEach {
+    v1_31Deps("io.opentelemetry:$it") {
+      version {
+        strictly("1.31.0-alpha")
+      }
+    }
   }
 }
 
@@ -92,10 +116,15 @@ tasks {
     configurations = listOf(v1_27Deps)
     archiveClassifier.set("v1_27")
   }
+  val v1_31Shadow by registering(ShadowJar::class) {
+    configurations = listOf(v1_31Deps)
+    archiveClassifier.set("v1_31")
+  }
 
   artifacts {
     add(v1_10.name, v1_10Shadow)
     add(v1_15.name, v1_15Shadow)
     add(v1_27.name, v1_27Shadow)
+    add(v1_31.name, v1_31Shadow)
   }
 }

settings.gradle.kts

@@ -400,6 +400,7 @@ include(":instrumentation:opentelemetry-api:opentelemetry-api-1.4:javaagent")
 include(":instrumentation:opentelemetry-api:opentelemetry-api-1.10:javaagent")
 include(":instrumentation:opentelemetry-api:opentelemetry-api-1.15:javaagent")
 include(":instrumentation:opentelemetry-api:opentelemetry-api-1.27:javaagent")
+include(":instrumentation:opentelemetry-api:opentelemetry-api-1.31: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")