Add experimental synchronous gauge

extensions/incubator/src/main/java/io/opentelemetry/extension/incubator/metrics/DoubleGauge.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.extension.incubator.metrics;
+
+import io.opentelemetry.api.common.Attributes;
+import javax.annotation.concurrent.ThreadSafe;
+
+/** A gauge instrument that synchronously records {@code double} values. */
+@ThreadSafe
+public interface DoubleGauge {
+  /**
+   * Set the gauge value.
+   *
+   * @param value The current gauge value.
+   */
+  void set(double value);
+
+  /**
+   * Records a value with a set of attributes.
+   *
+   * @param value The current gauge value.
+   * @param attributes A set of attributes to associate with the value.
+   */
+  void set(double value, Attributes attributes);
+
+  // TODO(jack-berg): should we add overload with Context argument?
+}

extensions/incubator/src/main/java/io/opentelemetry/extension/incubator/metrics/ExtendedDoubleGaugeBuilder.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.extension.incubator.metrics;
+
+import io.opentelemetry.api.metrics.DoubleGaugeBuilder;
+import java.util.function.Consumer;
+
+/** Extended {@link DoubleGaugeBuilder} with experimental APIs. */
+public interface ExtendedDoubleGaugeBuilder extends DoubleGaugeBuilder {
+
+  /**
+   * Builds and returns a DoubleGauge instrument with the configuration.
+   *
+   * <p>NOTE: This produces a synchronous gauge which records gauge values as they occur. Most users
+   * will want to instead register an {@link #buildWithCallback(Consumer)} to asynchronously observe
+   * the value of the gauge when metrics are collected.
+   *
+   * @return The DoubleGauge instrument.
+   */
+  DoubleGauge build();
+}

extensions/incubator/src/main/java/io/opentelemetry/extension/incubator/metrics/ExtendedLongGaugeBuilder.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.extension.incubator.metrics;
+
+import io.opentelemetry.api.metrics.LongGaugeBuilder;
+import java.util.function.Consumer;
+
+/** Extended {@link LongGaugeBuilder} with experimental APIs. */
+public interface ExtendedLongGaugeBuilder extends LongGaugeBuilder {
+
+  /**
+   * Builds and returns a LongGauge instrument with the configuration.
+   *
+   * <p>NOTE: This produces a synchronous gauge which records gauge values as they occur. Most users
+   * will want to instead register an {@link #buildWithCallback(Consumer)} to asynchronously observe
+   * the value of the gauge when metrics are collected.
+   *
+   * @return The LongGauge instrument.
+   */
+  LongGauge build();
+}

extensions/incubator/src/main/java/io/opentelemetry/extension/incubator/metrics/LongGauge.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.extension.incubator.metrics;
+
+import io.opentelemetry.api.common.Attributes;
+import javax.annotation.concurrent.ThreadSafe;
+
+/** A gauge instrument that synchronously records {@code long} values. */
+@ThreadSafe
+public interface LongGauge {
+  /**
+   * Set the gauge value.
+   *
+   * @param value The current gauge value.
+   */
+  void set(long value);
+
+  /**
+   * Records a value with a set of attributes.
+   *
+   * @param value The current gauge value.
+   * @param attributes A set of attributes to associate with the value.
+   */
+  void set(long value, Attributes attributes);
+
+  // TODO(jack-berg): should we add overload with Context argument?
+}

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/SdkDoubleGauge.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.metrics;
+
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.metrics.LongGaugeBuilder;
+import io.opentelemetry.api.metrics.ObservableDoubleGauge;
+import io.opentelemetry.api.metrics.ObservableDoubleMeasurement;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.extension.incubator.metrics.DoubleGauge;
+import io.opentelemetry.extension.incubator.metrics.ExtendedDoubleGaugeBuilder;
+import io.opentelemetry.sdk.metrics.internal.descriptor.InstrumentDescriptor;
+import io.opentelemetry.sdk.metrics.internal.state.MeterProviderSharedState;
+import io.opentelemetry.sdk.metrics.internal.state.MeterSharedState;
+import io.opentelemetry.sdk.metrics.internal.state.WriteableMetricStorage;
+import java.util.function.Consumer;
+
+final class SdkDoubleGauge extends AbstractInstrument implements DoubleGauge {
+
+  private final WriteableMetricStorage storage;
+
+  private SdkDoubleGauge(InstrumentDescriptor descriptor, WriteableMetricStorage storage) {
+    super(descriptor);
+    this.storage = storage;
+  }
+
+  @Override
+  public void set(double increment, Attributes attributes) {
+    storage.recordDouble(increment, attributes, Context.root());
+  }
+
+  @Override
+  public void set(double increment) {
+    set(increment, Attributes.empty());
+  }
+
+  static final class SdkDoubleGaugeBuilder extends AbstractInstrumentBuilder<SdkDoubleGaugeBuilder>
+      implements ExtendedDoubleGaugeBuilder {
+
+    SdkDoubleGaugeBuilder(
+        MeterProviderSharedState meterProviderSharedState,
+        MeterSharedState meterSharedState,
+        String name) {
+      super(
+          meterProviderSharedState,
+          meterSharedState,
+          // TODO: use InstrumentType.GAUGE when available
+          InstrumentType.OBSERVABLE_GAUGE,
+          InstrumentValueType.DOUBLE,
+          name,
+          "",
+          DEFAULT_UNIT);
+    }
+
+    @Override
+    protected SdkDoubleGaugeBuilder getThis() {
+      return this;
+    }
+
+    @Override
+    public SdkDoubleGauge build() {
+      return buildSynchronousInstrument(SdkDoubleGauge::new);
+    }
+
+    @Override
+    public LongGaugeBuilder ofLongs() {
+      return swapBuilder(SdkLongGauge.SdkLongGaugeBuilder::new);
+    }
+
+    @Override
+    public ObservableDoubleGauge buildWithCallback(Consumer<ObservableDoubleMeasurement> callback) {
+      // TODO: use InstrumentType.GAUGE when available
+      return registerDoubleAsynchronousInstrument(InstrumentType.OBSERVABLE_GAUGE, callback);
+    }
+
+    @Override
+    public ObservableDoubleMeasurement buildObserver() {
+      // TODO: use InstrumentType.GAUGE when available
+      return buildObservableMeasurement(InstrumentType.OBSERVABLE_GAUGE);
+    }
+  }
+}

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/SdkLongGauge.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.metrics;
+
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.metrics.ObservableLongGauge;
+import io.opentelemetry.api.metrics.ObservableLongMeasurement;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.extension.incubator.metrics.ExtendedLongGaugeBuilder;
+import io.opentelemetry.extension.incubator.metrics.LongGauge;
+import io.opentelemetry.sdk.metrics.internal.descriptor.Advice;
+import io.opentelemetry.sdk.metrics.internal.descriptor.InstrumentDescriptor;
+import io.opentelemetry.sdk.metrics.internal.state.MeterProviderSharedState;
+import io.opentelemetry.sdk.metrics.internal.state.MeterSharedState;
+import io.opentelemetry.sdk.metrics.internal.state.WriteableMetricStorage;
+import java.util.function.Consumer;
+
+final class SdkLongGauge extends AbstractInstrument implements LongGauge {
+
+  private final WriteableMetricStorage storage;
+
+  private SdkLongGauge(InstrumentDescriptor descriptor, WriteableMetricStorage storage) {
+    super(descriptor);
+    this.storage = storage;
+  }
+
+  @Override
+  public void set(long increment, Attributes attributes) {
+    storage.recordLong(increment, attributes, Context.root());
+  }
+
+  @Override
+  public void set(long increment) {
+    set(increment, Attributes.empty());
+  }
+
+  static final class SdkLongGaugeBuilder extends AbstractInstrumentBuilder<SdkLongGaugeBuilder>
+      implements ExtendedLongGaugeBuilder {
+
+    SdkLongGaugeBuilder(
+        MeterProviderSharedState meterProviderSharedState,
+        MeterSharedState sharedState,
+        String name,
+        String description,
+        String unit,
+        Advice.AdviceBuilder adviceBuilder) {
+      super(
+          meterProviderSharedState,
+          sharedState,
+          // TODO: use InstrumentType.GAUGE when available
+          InstrumentType.OBSERVABLE_GAUGE,
+          InstrumentValueType.LONG,
+          name,
+          description,
+          unit,
+          adviceBuilder);
+    }
+
+    @Override
+    protected SdkLongGaugeBuilder getThis() {
+      return this;
+    }
+
+    @Override
+    public SdkLongGauge build() {
+      return buildSynchronousInstrument(SdkLongGauge::new);
+    }
+
+    @Override
+    public ObservableLongGauge buildWithCallback(Consumer<ObservableLongMeasurement> callback) {
+      // TODO: use InstrumentType.GAUGE when available
+      return registerLongAsynchronousInstrument(InstrumentType.OBSERVABLE_GAUGE, callback);
+    }
+
+    @Override
+    public ObservableLongMeasurement buildObserver() {
+      // TODO: use InstrumentType.GAUGE when available
+      return buildObservableMeasurement(InstrumentType.OBSERVABLE_GAUGE);
+    }
+  }
+}

sdk/metrics/src/main/java/io/opentelemetry/sdk/metrics/SdkMeter.java

@@ -108,7 +108,8 @@ public DoubleHistogramBuilder histogramBuilder(String name) {
   public DoubleGaugeBuilder gaugeBuilder(String name) {
     return !checkValidInstrumentName(name)
         ? NOOP_METER.gaugeBuilder(NOOP_INSTRUMENT_NAME)
-        : new SdkDoubleGaugeBuilder(meterProviderSharedState, meterSharedState, name);
+        : new SdkDoubleGauge.SdkDoubleGaugeBuilder(
+            meterProviderSharedState, meterSharedState, name);
   }
 
   @Override