diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleCounter.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleCounter.java new file mode 100644 index 00000000000..c1584ed24c4 --- /dev/null +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleCounter.java @@ -0,0 +1,75 @@ +package datadog.opentelemetry.shim.metrics; + +import static datadog.opentelemetry.shim.metrics.OtelInstrumentBuilder.ofDoubles; +import static datadog.opentelemetry.shim.metrics.OtelInstrumentType.COUNTER; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_INSTRUMENT_NAME; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_METER; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.DoubleCounter; +import io.opentelemetry.api.metrics.DoubleCounterBuilder; +import io.opentelemetry.api.metrics.ObservableDoubleCounter; +import io.opentelemetry.api.metrics.ObservableDoubleMeasurement; +import io.opentelemetry.context.Context; +import java.util.function.Consumer; +import javax.annotation.ParametersAreNonnullByDefault; + +@ParametersAreNonnullByDefault +final class OtelDoubleCounter implements DoubleCounter { + + @Override + public void add(double value) { + // FIXME: implement recording + } + + @Override + public void add(double value, Attributes attributes) { + // FIXME: implement recording + } + + @Override + public void add(double value, Attributes attributes, Context context) { + // FIXME: implement recording + } + + static final class Builder implements DoubleCounterBuilder { + private final OtelInstrumentBuilder instrumentBuilder; + + Builder(OtelInstrumentBuilder builder) { + this.instrumentBuilder = ofDoubles(builder, COUNTER); + } + + @Override + public DoubleCounterBuilder setDescription(String description) { + instrumentBuilder.setDescription(description); + return this; + } + + @Override + public DoubleCounterBuilder setUnit(String unit) { + instrumentBuilder.setUnit(unit); + return this; + } + + @Override + public DoubleCounter build() { + return new OtelDoubleCounter(); + } + + @Override + public ObservableDoubleCounter buildWithCallback( + Consumer callback) { + // FIXME: implement callback + return NOOP_METER + .counterBuilder(NOOP_INSTRUMENT_NAME) + .ofDoubles() + .buildWithCallback(callback); + } + + @Override + public ObservableDoubleMeasurement buildObserver() { + // FIXME: implement observer + return NOOP_METER.counterBuilder(NOOP_INSTRUMENT_NAME).ofDoubles().buildObserver(); + } + } +} diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleGauge.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleGauge.java new file mode 100644 index 00000000000..1929175be72 --- /dev/null +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleGauge.java @@ -0,0 +1,77 @@ +package datadog.opentelemetry.shim.metrics; + +import static datadog.opentelemetry.shim.metrics.OtelInstrumentBuilder.ofDoubles; +import static datadog.opentelemetry.shim.metrics.OtelInstrumentType.GAUGE; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_INSTRUMENT_NAME; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_METER; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.DoubleGauge; +import io.opentelemetry.api.metrics.DoubleGaugeBuilder; +import io.opentelemetry.api.metrics.LongGaugeBuilder; +import io.opentelemetry.api.metrics.ObservableDoubleGauge; +import io.opentelemetry.api.metrics.ObservableDoubleMeasurement; +import io.opentelemetry.context.Context; +import java.util.function.Consumer; +import javax.annotation.ParametersAreNonnullByDefault; + +@ParametersAreNonnullByDefault +final class OtelDoubleGauge implements DoubleGauge { + + @Override + public void set(double value) { + // FIXME: implement recording + } + + @Override + public void set(double value, Attributes attributes) { + // FIXME: implement recording + } + + @Override + public void set(double value, Attributes attributes, Context context) { + // FIXME: implement recording + } + + static final class Builder implements DoubleGaugeBuilder { + private final OtelInstrumentBuilder instrumentBuilder; + + Builder(OtelMeter meter, String instrumentName) { + this.instrumentBuilder = ofDoubles(meter, instrumentName, GAUGE); + } + + @Override + public DoubleGaugeBuilder setDescription(String description) { + instrumentBuilder.setDescription(description); + return this; + } + + @Override + public DoubleGaugeBuilder setUnit(String unit) { + instrumentBuilder.setUnit(unit); + return this; + } + + @Override + public LongGaugeBuilder ofLongs() { + return new OtelLongGauge.Builder(instrumentBuilder); + } + + @Override + public DoubleGauge build() { + return new OtelDoubleGauge(); + } + + @Override + public ObservableDoubleGauge buildWithCallback(Consumer callback) { + // FIXME: implement callback + return NOOP_METER.gaugeBuilder(NOOP_INSTRUMENT_NAME).buildWithCallback(callback); + } + + @Override + public ObservableDoubleMeasurement buildObserver() { + // FIXME: implement observer + return NOOP_METER.gaugeBuilder(NOOP_INSTRUMENT_NAME).buildObserver(); + } + } +} diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleHistogram.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleHistogram.java new file mode 100644 index 00000000000..bbc3612c5ec --- /dev/null +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleHistogram.java @@ -0,0 +1,67 @@ +package datadog.opentelemetry.shim.metrics; + +import static datadog.opentelemetry.shim.metrics.OtelInstrumentBuilder.ofDoubles; +import static datadog.opentelemetry.shim.metrics.OtelInstrumentType.HISTOGRAM; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.DoubleHistogram; +import io.opentelemetry.api.metrics.DoubleHistogramBuilder; +import io.opentelemetry.api.metrics.LongHistogramBuilder; +import io.opentelemetry.context.Context; +import java.util.List; +import javax.annotation.ParametersAreNonnullByDefault; + +@ParametersAreNonnullByDefault +final class OtelDoubleHistogram implements DoubleHistogram { + + @Override + public void record(double value) { + // FIXME: implement recording + } + + @Override + public void record(double value, Attributes attributes) { + // FIXME: implement recording + } + + @Override + public void record(double value, Attributes attributes, Context context) { + // FIXME: implement recording + } + + static final class Builder implements DoubleHistogramBuilder { + private final OtelInstrumentBuilder instrumentBuilder; + + Builder(OtelMeter meter, String instrumentName) { + this.instrumentBuilder = ofDoubles(meter, instrumentName, HISTOGRAM); + } + + @Override + public DoubleHistogramBuilder setDescription(String description) { + instrumentBuilder.setDescription(description); + return this; + } + + @Override + public DoubleHistogramBuilder setUnit(String unit) { + instrumentBuilder.setUnit(unit); + return this; + } + + @Override + public DoubleHistogramBuilder setExplicitBucketBoundariesAdvice(List bucketBoundaries) { + // FIXME: implement boundary advice + return this; + } + + @Override + public LongHistogramBuilder ofLongs() { + return new OtelLongHistogram.Builder(instrumentBuilder); + } + + @Override + public DoubleHistogram build() { + return new OtelDoubleHistogram(); + } + } +} diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleUpDownCounter.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleUpDownCounter.java new file mode 100644 index 00000000000..32b68931659 --- /dev/null +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelDoubleUpDownCounter.java @@ -0,0 +1,75 @@ +package datadog.opentelemetry.shim.metrics; + +import static datadog.opentelemetry.shim.metrics.OtelInstrumentBuilder.ofDoubles; +import static datadog.opentelemetry.shim.metrics.OtelInstrumentType.UP_DOWN_COUNTER; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_INSTRUMENT_NAME; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_METER; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.DoubleUpDownCounter; +import io.opentelemetry.api.metrics.DoubleUpDownCounterBuilder; +import io.opentelemetry.api.metrics.ObservableDoubleMeasurement; +import io.opentelemetry.api.metrics.ObservableDoubleUpDownCounter; +import io.opentelemetry.context.Context; +import java.util.function.Consumer; +import javax.annotation.ParametersAreNonnullByDefault; + +@ParametersAreNonnullByDefault +final class OtelDoubleUpDownCounter implements DoubleUpDownCounter { + + @Override + public void add(double value) { + // FIXME: implement recording + } + + @Override + public void add(double value, Attributes attributes) { + // FIXME: implement recording + } + + @Override + public void add(double value, Attributes attributes, Context context) { + // FIXME: implement recording + } + + static final class Builder implements DoubleUpDownCounterBuilder { + private final OtelInstrumentBuilder instrumentBuilder; + + Builder(OtelInstrumentBuilder builder) { + this.instrumentBuilder = ofDoubles(builder, UP_DOWN_COUNTER); + } + + @Override + public DoubleUpDownCounterBuilder setDescription(String description) { + instrumentBuilder.setDescription(description); + return this; + } + + @Override + public DoubleUpDownCounterBuilder setUnit(String unit) { + instrumentBuilder.setUnit(unit); + return this; + } + + @Override + public DoubleUpDownCounter build() { + return new OtelDoubleUpDownCounter(); + } + + @Override + public ObservableDoubleUpDownCounter buildWithCallback( + Consumer callback) { + // FIXME: implement callback + return NOOP_METER + .upDownCounterBuilder(NOOP_INSTRUMENT_NAME) + .ofDoubles() + .buildWithCallback(callback); + } + + @Override + public ObservableDoubleMeasurement buildObserver() { + // FIXME: implement observer + return NOOP_METER.upDownCounterBuilder(NOOP_INSTRUMENT_NAME).ofDoubles().buildObserver(); + } + } +} diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelInstrumentBuilder.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelInstrumentBuilder.java new file mode 100644 index 00000000000..494cefea84f --- /dev/null +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelInstrumentBuilder.java @@ -0,0 +1,83 @@ +package datadog.opentelemetry.shim.metrics; + +import javax.annotation.Nullable; + +final class OtelInstrumentBuilder { + + private final OtelMeter meter; + private final String instrumentName; + private final OtelInstrumentType instrumentType; + private final boolean longValues; + + @Nullable private String description; + @Nullable private String unit; + + /** + * Starts building an instrument of long values with the given name and type. + * + * @param meter the owning mete + * @param instrumentName the name of the instrument + * @param instrumentType the type of the instrument + * @return new instrument builder + */ + static OtelInstrumentBuilder ofLongs( + OtelMeter meter, String instrumentName, OtelInstrumentType instrumentType) { + return new OtelInstrumentBuilder(meter, instrumentName, instrumentType, true); + } + + /** + * Starts building an instrument of long values based on another builder. + * + * @param builder the builder to copy details from + * @param instrumentType the type of the instrument + * @return new instrument builder + */ + static OtelInstrumentBuilder ofLongs( + OtelInstrumentBuilder builder, OtelInstrumentType instrumentType) { + return new OtelInstrumentBuilder(builder.meter, builder.instrumentName, instrumentType, true); + } + + /** + * Starts building an instrument of double values with the given name and type. + * + * @param meter the owning mete + * @param instrumentName the name of the instrument + * @param instrumentType the type of the instrument + * @return new instrument builder + */ + static OtelInstrumentBuilder ofDoubles( + OtelMeter meter, String instrumentName, OtelInstrumentType instrumentType) { + return new OtelInstrumentBuilder(meter, instrumentName, instrumentType, false); + } + + /** + * Starts building an instrument of double values based on another builder. + * + * @param builder the builder to copy details from + * @param instrumentType the type of the instrument + * @return new instrument builder + */ + static OtelInstrumentBuilder ofDoubles( + OtelInstrumentBuilder builder, OtelInstrumentType instrumentType) { + return new OtelInstrumentBuilder(builder.meter, builder.instrumentName, instrumentType, false); + } + + private OtelInstrumentBuilder( + OtelMeter meter, + String instrumentName, + OtelInstrumentType instrumentType, + boolean longValues) { + this.meter = meter; + this.instrumentName = instrumentName; + this.instrumentType = instrumentType; + this.longValues = longValues; + } + + void setDescription(String description) { + this.description = description; + } + + void setUnit(String unit) { + this.unit = unit; + } +} diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelInstrumentType.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelInstrumentType.java new file mode 100644 index 00000000000..338b842ed87 --- /dev/null +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelInstrumentType.java @@ -0,0 +1,8 @@ +package datadog.opentelemetry.shim.metrics; + +enum OtelInstrumentType { + COUNTER, + UP_DOWN_COUNTER, + HISTOGRAM, + GAUGE +} diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongCounter.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongCounter.java new file mode 100644 index 00000000000..c387c5b8104 --- /dev/null +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongCounter.java @@ -0,0 +1,77 @@ +package datadog.opentelemetry.shim.metrics; + +import static datadog.opentelemetry.shim.metrics.OtelInstrumentBuilder.ofLongs; +import static datadog.opentelemetry.shim.metrics.OtelInstrumentType.COUNTER; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_INSTRUMENT_NAME; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_METER; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.DoubleCounterBuilder; +import io.opentelemetry.api.metrics.LongCounter; +import io.opentelemetry.api.metrics.LongCounterBuilder; +import io.opentelemetry.api.metrics.ObservableLongCounter; +import io.opentelemetry.api.metrics.ObservableLongMeasurement; +import io.opentelemetry.context.Context; +import java.util.function.Consumer; +import javax.annotation.ParametersAreNonnullByDefault; + +@ParametersAreNonnullByDefault +final class OtelLongCounter implements LongCounter { + + @Override + public void add(long value) { + // FIXME: implement recording + } + + @Override + public void add(long value, Attributes attributes) { + // FIXME: implement recording + } + + @Override + public void add(long value, Attributes attributes, Context context) { + // FIXME: implement recording + } + + static final class Builder implements LongCounterBuilder { + private final OtelInstrumentBuilder instrumentBuilder; + + Builder(OtelMeter meter, String instrumentName) { + this.instrumentBuilder = ofLongs(meter, instrumentName, COUNTER); + } + + @Override + public LongCounterBuilder setDescription(String description) { + instrumentBuilder.setDescription(description); + return this; + } + + @Override + public LongCounterBuilder setUnit(String unit) { + instrumentBuilder.setUnit(unit); + return this; + } + + @Override + public DoubleCounterBuilder ofDoubles() { + return new OtelDoubleCounter.Builder(instrumentBuilder); + } + + @Override + public LongCounter build() { + return new OtelLongCounter(); + } + + @Override + public ObservableLongCounter buildWithCallback(Consumer callback) { + // FIXME: implement callback + return NOOP_METER.counterBuilder(NOOP_INSTRUMENT_NAME).buildWithCallback(callback); + } + + @Override + public ObservableLongMeasurement buildObserver() { + // FIXME: implement observer + return NOOP_METER.counterBuilder(NOOP_INSTRUMENT_NAME).buildObserver(); + } + } +} diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongGauge.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongGauge.java new file mode 100644 index 00000000000..97f708d49e5 --- /dev/null +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongGauge.java @@ -0,0 +1,71 @@ +package datadog.opentelemetry.shim.metrics; + +import static datadog.opentelemetry.shim.metrics.OtelInstrumentBuilder.ofLongs; +import static datadog.opentelemetry.shim.metrics.OtelInstrumentType.GAUGE; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_INSTRUMENT_NAME; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_METER; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.LongGauge; +import io.opentelemetry.api.metrics.LongGaugeBuilder; +import io.opentelemetry.api.metrics.ObservableLongGauge; +import io.opentelemetry.api.metrics.ObservableLongMeasurement; +import io.opentelemetry.context.Context; +import java.util.function.Consumer; +import javax.annotation.ParametersAreNonnullByDefault; + +@ParametersAreNonnullByDefault +final class OtelLongGauge implements LongGauge { + + @Override + public void set(long value) { + // FIXME: implement recording + } + + @Override + public void set(long value, Attributes attributes) { + // FIXME: implement recording + } + + @Override + public void set(long value, Attributes attributes, Context context) { + // FIXME: implement recording + } + + static final class Builder implements LongGaugeBuilder { + private final OtelInstrumentBuilder instrumentBuilder; + + Builder(OtelInstrumentBuilder builder) { + this.instrumentBuilder = ofLongs(builder, GAUGE); + } + + @Override + public LongGaugeBuilder setDescription(String description) { + instrumentBuilder.setDescription(description); + return this; + } + + @Override + public LongGaugeBuilder setUnit(String unit) { + instrumentBuilder.setUnit(unit); + return this; + } + + @Override + public LongGauge build() { + return new OtelLongGauge(); + } + + @Override + public ObservableLongGauge buildWithCallback(Consumer callback) { + // FIXME: implement callback + return NOOP_METER.gaugeBuilder(NOOP_INSTRUMENT_NAME).ofLongs().buildWithCallback(callback); + } + + @Override + public ObservableLongMeasurement buildObserver() { + // FIXME: implement observer + return NOOP_METER.gaugeBuilder(NOOP_INSTRUMENT_NAME).ofLongs().buildObserver(); + } + } +} diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongHistogram.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongHistogram.java new file mode 100644 index 00000000000..c005bc10806 --- /dev/null +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongHistogram.java @@ -0,0 +1,61 @@ +package datadog.opentelemetry.shim.metrics; + +import static datadog.opentelemetry.shim.metrics.OtelInstrumentBuilder.ofLongs; +import static datadog.opentelemetry.shim.metrics.OtelInstrumentType.HISTOGRAM; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.LongHistogram; +import io.opentelemetry.api.metrics.LongHistogramBuilder; +import io.opentelemetry.context.Context; +import java.util.List; +import javax.annotation.ParametersAreNonnullByDefault; + +@ParametersAreNonnullByDefault +final class OtelLongHistogram implements LongHistogram { + + @Override + public void record(long value) { + // FIXME: implement recording + } + + @Override + public void record(long value, Attributes attributes) { + // FIXME: implement recording + } + + @Override + public void record(long value, Attributes attributes, Context context) { + // FIXME: implement recording + } + + static final class Builder implements LongHistogramBuilder { + private final OtelInstrumentBuilder instrumentBuilder; + + Builder(OtelInstrumentBuilder builder) { + this.instrumentBuilder = ofLongs(builder, HISTOGRAM); + } + + @Override + public LongHistogramBuilder setDescription(String description) { + instrumentBuilder.setDescription(description); + return this; + } + + @Override + public LongHistogramBuilder setUnit(String unit) { + instrumentBuilder.setUnit(unit); + return this; + } + + @Override + public LongHistogramBuilder setExplicitBucketBoundariesAdvice(List bucketBoundaries) { + // FIXME: implement boundary advice + return this; + } + + @Override + public LongHistogram build() { + return new OtelLongHistogram(); + } + } +} diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongUpDownCounter.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongUpDownCounter.java new file mode 100644 index 00000000000..d53eb468592 --- /dev/null +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelLongUpDownCounter.java @@ -0,0 +1,78 @@ +package datadog.opentelemetry.shim.metrics; + +import static datadog.opentelemetry.shim.metrics.OtelInstrumentBuilder.ofLongs; +import static datadog.opentelemetry.shim.metrics.OtelInstrumentType.UP_DOWN_COUNTER; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_INSTRUMENT_NAME; +import static datadog.opentelemetry.shim.metrics.OtelMeter.NOOP_METER; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.metrics.DoubleUpDownCounterBuilder; +import io.opentelemetry.api.metrics.LongUpDownCounter; +import io.opentelemetry.api.metrics.LongUpDownCounterBuilder; +import io.opentelemetry.api.metrics.ObservableLongMeasurement; +import io.opentelemetry.api.metrics.ObservableLongUpDownCounter; +import io.opentelemetry.context.Context; +import java.util.function.Consumer; +import javax.annotation.ParametersAreNonnullByDefault; + +@ParametersAreNonnullByDefault +final class OtelLongUpDownCounter implements LongUpDownCounter { + + @Override + public void add(long value) { + // FIXME: implement recording + } + + @Override + public void add(long value, Attributes attributes) { + // FIXME: implement recording + } + + @Override + public void add(long value, Attributes attributes, Context context) { + // FIXME: implement recording + } + + static final class Builder implements LongUpDownCounterBuilder { + private final OtelInstrumentBuilder instrumentBuilder; + + Builder(OtelMeter meter, String instrumentName) { + this.instrumentBuilder = ofLongs(meter, instrumentName, UP_DOWN_COUNTER); + } + + @Override + public LongUpDownCounterBuilder setDescription(String description) { + instrumentBuilder.setDescription(description); + return this; + } + + @Override + public LongUpDownCounterBuilder setUnit(String unit) { + instrumentBuilder.setUnit(unit); + return this; + } + + @Override + public DoubleUpDownCounterBuilder ofDoubles() { + return new OtelDoubleUpDownCounter.Builder(instrumentBuilder); + } + + @Override + public LongUpDownCounter build() { + return new OtelLongUpDownCounter(); + } + + @Override + public ObservableLongUpDownCounter buildWithCallback( + Consumer callback) { + // FIXME: implement callback + return NOOP_METER.upDownCounterBuilder(NOOP_INSTRUMENT_NAME).buildWithCallback(callback); + } + + @Override + public ObservableLongMeasurement buildObserver() { + // FIXME: implement observer + return NOOP_METER.upDownCounterBuilder(NOOP_INSTRUMENT_NAME).buildObserver(); + } + } +} diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelMeter.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelMeter.java index 333844cecbc..39345aef96e 100644 --- a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelMeter.java +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/metrics/OtelMeter.java @@ -7,32 +7,60 @@ import io.opentelemetry.api.metrics.LongCounterBuilder; import io.opentelemetry.api.metrics.LongUpDownCounterBuilder; import io.opentelemetry.api.metrics.Meter; +import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.api.metrics.ObservableMeasurement; +import java.util.regex.Pattern; +import javax.annotation.Nullable; import javax.annotation.ParametersAreNonnullByDefault; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; @ParametersAreNonnullByDefault final class OtelMeter implements Meter { + private static final Logger LOGGER = LoggerFactory.getLogger(OtelMeter.class); - OtelMeter(@SuppressWarnings("unused") OtelInstrumentationScope instrumentationScope) {} + private static final Pattern VALID_INSTRUMENT_NAME_PATTERN = + Pattern.compile("([A-Za-z])([A-Za-z0-9_\\-./]){0,254}"); + + static final Meter NOOP_METER = MeterProvider.noop().get("noop"); + static final String NOOP_INSTRUMENT_NAME = "noop"; + + private final OtelInstrumentationScope instrumentationScope; + + OtelMeter(OtelInstrumentationScope instrumentationScope) { + this.instrumentationScope = instrumentationScope; + } @Override public LongCounterBuilder counterBuilder(String instrumentName) { - throw new UnsupportedOperationException("counterBuilder is not yet supported"); + if (!validInstrumentName(instrumentName)) { + return NOOP_METER.counterBuilder(NOOP_INSTRUMENT_NAME); + } + return new OtelLongCounter.Builder(this, instrumentName); } @Override public LongUpDownCounterBuilder upDownCounterBuilder(String instrumentName) { - throw new UnsupportedOperationException("upDownCounterBuilder is not yet supported"); + if (!validInstrumentName(instrumentName)) { + return NOOP_METER.upDownCounterBuilder(NOOP_INSTRUMENT_NAME); + } + return new OtelLongUpDownCounter.Builder(this, instrumentName); } @Override public DoubleHistogramBuilder histogramBuilder(String instrumentName) { - throw new UnsupportedOperationException("histogramBuilder is not yet supported"); + if (!validInstrumentName(instrumentName)) { + return NOOP_METER.histogramBuilder(NOOP_INSTRUMENT_NAME); + } + return new OtelDoubleHistogram.Builder(this, instrumentName); } @Override public DoubleGaugeBuilder gaugeBuilder(String instrumentName) { - throw new UnsupportedOperationException("gaugeBuilder is not yet supported"); + if (!validInstrumentName(instrumentName)) { + return NOOP_METER.gaugeBuilder(NOOP_INSTRUMENT_NAME); + } + return new OtelDoubleGauge.Builder(this, instrumentName); } @Override @@ -40,6 +68,26 @@ public BatchCallback batchCallback( Runnable callback, ObservableMeasurement observableMeasurement, ObservableMeasurement... additionalMeasurements) { - throw new UnsupportedOperationException("batchCallback is not yet supported"); + // FIXME: implement callback + return NOOP_METER.batchCallback(callback, observableMeasurement, additionalMeasurements); + } + + @Override + public String toString() { + return "OtelMeter{instrumentationScope=" + instrumentationScope + "}"; + } + + private static boolean validInstrumentName(@Nullable String instrumentName) { + if (instrumentName != null && VALID_INSTRUMENT_NAME_PATTERN.matcher(instrumentName).matches()) { + return true; + } + + LOGGER.warn( + "Instrument name \"{}\" is invalid, returning noop instrument." + + " Instrument names must consist of 255 or fewer characters" + + " including alphanumeric, _, ., -, /, and start with a letter.", + instrumentName); + + return false; } }