diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetrics.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetrics.java index e31eeb09ff0d..01acfb70e980 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetrics.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetrics.java @@ -7,20 +7,20 @@ import static io.opentelemetry.instrumentation.api.instrumenter.http.HttpMessageBodySizeUtil.getHttpRequestBodySize; import static io.opentelemetry.instrumentation.api.instrumenter.http.HttpMessageBodySizeUtil.getHttpResponseBodySize; -import static io.opentelemetry.instrumentation.api.instrumenter.http.HttpMetricsUtil.createDurationHistogram; -import static io.opentelemetry.instrumentation.api.instrumenter.http.HttpMetricsUtil.nanosToUnit; import static io.opentelemetry.instrumentation.api.instrumenter.http.TemporaryMetricsView.applyClientDurationAndSizeView; import static java.util.logging.Level.FINE; import com.google.auto.value.AutoValue; import io.opentelemetry.api.common.Attributes; -import io.opentelemetry.api.metrics.DoubleHistogram; import io.opentelemetry.api.metrics.LongHistogram; import io.opentelemetry.api.metrics.Meter; import io.opentelemetry.context.Context; import io.opentelemetry.context.ContextKey; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; import io.opentelemetry.instrumentation.api.instrumenter.OperationMetrics; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogram; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogramFactory; +import java.util.concurrent.TimeUnit; import java.util.logging.Logger; /** @@ -44,13 +44,13 @@ public static OperationMetrics get() { return HttpClientMetrics::new; } - private final DoubleHistogram duration; + private final DurationHistogram duration; private final LongHistogram requestSize; private final LongHistogram responseSize; private HttpClientMetrics(Meter meter) { duration = - createDurationHistogram( + DurationHistogramFactory.create( meter, "http.client.duration", "The duration of the outbound HTTP request"); requestSize = meter @@ -89,7 +89,10 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { Attributes durationAndSizeAttributes = applyClientDurationAndSizeView(state.startAttributes(), endAttributes); duration.record( - nanosToUnit(endNanos - state.startTimeNanos()), durationAndSizeAttributes, context); + endNanos - state.startTimeNanos(), + TimeUnit.NANOSECONDS, + durationAndSizeAttributes, + context); Long requestBodySize = getHttpRequestBodySize(endAttributes, state.startAttributes()); if (requestBodySize != null) { diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMetricsUtil.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMetricsUtil.java deleted file mode 100644 index fcbbd8238977..000000000000 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpMetricsUtil.java +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.api.instrumenter.http; - -import static java.util.Arrays.asList; -import static java.util.Collections.unmodifiableList; - -import io.opentelemetry.api.metrics.DoubleHistogram; -import io.opentelemetry.api.metrics.DoubleHistogramBuilder; -import io.opentelemetry.api.metrics.Meter; -import io.opentelemetry.extension.incubator.metrics.ExtendedDoubleHistogramBuilder; -import io.opentelemetry.instrumentation.api.internal.SemconvStability; -import java.util.List; -import java.util.concurrent.TimeUnit; - -final class HttpMetricsUtil { - - // we'll use the old unit if the old semconv is in use - private static final boolean useSeconds = - SemconvStability.emitStableHttpSemconv() && !SemconvStability.emitOldHttpSemconv(); - - static final List DURATION_SECONDS_BUCKETS = - unmodifiableList( - asList( - 0.0, 0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1.0, 2.5, 5.0, 7.5, - 10.0)); - - private static final double NANOS_PER_MS = TimeUnit.MILLISECONDS.toNanos(1); - private static final double NANOS_PER_S = TimeUnit.SECONDS.toNanos(1); - - static DoubleHistogram createDurationHistogram(Meter meter, String name, String description) { - DoubleHistogramBuilder durationBuilder = - meter.histogramBuilder(name).setUnit(useSeconds ? "s" : "ms").setDescription(description); - // don't set custom buckets if milliseconds are still used - if (useSeconds && durationBuilder instanceof ExtendedDoubleHistogramBuilder) { - ((ExtendedDoubleHistogramBuilder) durationBuilder) - .setAdvice(advice -> advice.setExplicitBucketBoundaries(DURATION_SECONDS_BUCKETS)); - } - return durationBuilder.build(); - } - - static double nanosToUnit(long durationNanos) { - return durationNanos / (useSeconds ? NANOS_PER_S : NANOS_PER_MS); - } - - private HttpMetricsUtil() {} -} diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetrics.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetrics.java index 25fb7c1f0692..153be55e7e9a 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetrics.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetrics.java @@ -7,15 +7,12 @@ import static io.opentelemetry.instrumentation.api.instrumenter.http.HttpMessageBodySizeUtil.getHttpRequestBodySize; import static io.opentelemetry.instrumentation.api.instrumenter.http.HttpMessageBodySizeUtil.getHttpResponseBodySize; -import static io.opentelemetry.instrumentation.api.instrumenter.http.HttpMetricsUtil.createDurationHistogram; -import static io.opentelemetry.instrumentation.api.instrumenter.http.HttpMetricsUtil.nanosToUnit; import static io.opentelemetry.instrumentation.api.instrumenter.http.TemporaryMetricsView.applyActiveRequestsView; import static io.opentelemetry.instrumentation.api.instrumenter.http.TemporaryMetricsView.applyServerDurationAndSizeView; import static java.util.logging.Level.FINE; import com.google.auto.value.AutoValue; import io.opentelemetry.api.common.Attributes; -import io.opentelemetry.api.metrics.DoubleHistogram; import io.opentelemetry.api.metrics.LongHistogram; import io.opentelemetry.api.metrics.LongUpDownCounter; import io.opentelemetry.api.metrics.Meter; @@ -23,6 +20,9 @@ import io.opentelemetry.context.ContextKey; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; import io.opentelemetry.instrumentation.api.instrumenter.OperationMetrics; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogram; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogramFactory; +import java.util.concurrent.TimeUnit; import java.util.logging.Logger; /** @@ -47,7 +47,7 @@ public static OperationMetrics get() { } private final LongUpDownCounter activeRequests; - private final DoubleHistogram duration; + private final DurationHistogram duration; private final LongHistogram requestSize; private final LongHistogram responseSize; @@ -59,7 +59,7 @@ private HttpServerMetrics(Meter meter) { .setDescription("The number of concurrent HTTP requests that are currently in-flight") .build(); duration = - createDurationHistogram( + DurationHistogramFactory.create( meter, "http.server.duration", "The duration of the inbound HTTP request"); requestSize = meter @@ -103,7 +103,10 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { Attributes durationAndSizeAttributes = applyServerDurationAndSizeView(state.startAttributes(), endAttributes); duration.record( - nanosToUnit(endNanos - state.startTimeNanos()), durationAndSizeAttributes, context); + endNanos - state.startTimeNanos(), + TimeUnit.NANOSECONDS, + durationAndSizeAttributes, + context); Long requestBodySize = getHttpRequestBodySize(endAttributes, state.startAttributes()); if (requestBodySize != null) { diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcClientMetrics.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcClientMetrics.java index eba0bfbd6e34..8d38f724ee56 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcClientMetrics.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcClientMetrics.java @@ -10,12 +10,13 @@ import com.google.auto.value.AutoValue; import io.opentelemetry.api.common.Attributes; -import io.opentelemetry.api.metrics.DoubleHistogram; import io.opentelemetry.api.metrics.Meter; import io.opentelemetry.context.Context; import io.opentelemetry.context.ContextKey; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; import io.opentelemetry.instrumentation.api.instrumenter.OperationMetrics; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogram; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogramFactory; import java.util.concurrent.TimeUnit; import java.util.logging.Logger; @@ -26,22 +27,17 @@ */ public final class RpcClientMetrics implements OperationListener { - private static final double NANOS_PER_MS = TimeUnit.MILLISECONDS.toNanos(1); - private static final ContextKey RPC_CLIENT_REQUEST_METRICS_STATE = ContextKey.named("rpc-client-request-metrics-state"); private static final Logger logger = Logger.getLogger(RpcClientMetrics.class.getName()); - private final DoubleHistogram clientDurationHistogram; + private final DurationHistogram clientDurationHistogram; private RpcClientMetrics(Meter meter) { clientDurationHistogram = - meter - .histogramBuilder("rpc.client.duration") - .setDescription("The duration of an outbound RPC invocation") - .setUnit("ms") - .build(); + DurationHistogramFactory.create( + meter, "rpc.client.duration", "The duration of an outbound RPC invocation"); } /** @@ -71,7 +67,8 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { return; } clientDurationHistogram.record( - (endNanos - state.startTimeNanos()) / NANOS_PER_MS, + endNanos - state.startTimeNanos(), + TimeUnit.NANOSECONDS, applyClientView(state.startAttributes(), endAttributes), context); } diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcServerMetrics.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcServerMetrics.java index 2c54283086f0..9b1ca3503848 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcServerMetrics.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcServerMetrics.java @@ -10,12 +10,13 @@ import com.google.auto.value.AutoValue; import io.opentelemetry.api.common.Attributes; -import io.opentelemetry.api.metrics.DoubleHistogram; import io.opentelemetry.api.metrics.Meter; import io.opentelemetry.context.Context; import io.opentelemetry.context.ContextKey; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; import io.opentelemetry.instrumentation.api.instrumenter.OperationMetrics; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogram; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogramFactory; import java.util.concurrent.TimeUnit; import java.util.logging.Logger; @@ -26,22 +27,17 @@ */ public final class RpcServerMetrics implements OperationListener { - private static final double NANOS_PER_MS = TimeUnit.MILLISECONDS.toNanos(1); - private static final ContextKey RPC_SERVER_REQUEST_METRICS_STATE = ContextKey.named("rpc-server-request-metrics-state"); private static final Logger logger = Logger.getLogger(RpcServerMetrics.class.getName()); - private final DoubleHistogram serverDurationHistogram; + private final DurationHistogram serverDurationHistogram; private RpcServerMetrics(Meter meter) { serverDurationHistogram = - meter - .histogramBuilder("rpc.server.duration") - .setDescription("The duration of an inbound RPC invocation") - .setUnit("ms") - .build(); + DurationHistogramFactory.create( + meter, "rpc.server.duration", "The duration of an inbound RPC invocation"); } /** @@ -71,7 +67,8 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { return; } serverDurationHistogram.record( - (endNanos - state.startTimeNanos()) / NANOS_PER_MS, + endNanos - state.startTimeNanos(), + TimeUnit.NANOSECONDS, applyServerView(state.startAttributes(), endAttributes), context); } diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/metrics/db/DbConnectionPoolMetrics.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/metrics/db/DbConnectionPoolMetrics.java index b70ac29a979c..5e21cce07afd 100644 --- a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/metrics/db/DbConnectionPoolMetrics.java +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/metrics/db/DbConnectionPoolMetrics.java @@ -11,13 +11,14 @@ import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.metrics.BatchCallback; -import io.opentelemetry.api.metrics.DoubleHistogram; import io.opentelemetry.api.metrics.LongCounter; import io.opentelemetry.api.metrics.Meter; import io.opentelemetry.api.metrics.MeterBuilder; import io.opentelemetry.api.metrics.ObservableLongMeasurement; import io.opentelemetry.api.metrics.ObservableMeasurement; import io.opentelemetry.instrumentation.api.internal.EmbeddedInstrumentationProperties; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogram; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogramFactory; /** * A helper class that models the This class is internal and is hence not for public use. Its APIs are unstable and can change + * at any time. + */ +@ThreadSafe +public final class DurationHistogram { + + private final DoubleHistogram delegate; + + DurationHistogram(DoubleHistogram delegate) { + this.delegate = delegate; + } + + public void record(long value, TimeUnit unit) { + delegate.record(DurationHistogramFactory.toUnit(value, unit)); + } + + public void record(long value, TimeUnit unit, Attributes attributes) { + delegate.record(DurationHistogramFactory.toUnit(value, unit), attributes); + } + + public void record(long value, TimeUnit unit, Attributes attributes, Context context) { + delegate.record(DurationHistogramFactory.toUnit(value, unit), attributes, context); + } +} diff --git a/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/metrics/internal/DurationHistogramFactory.java b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/metrics/internal/DurationHistogramFactory.java new file mode 100644 index 000000000000..d738bdefa1e2 --- /dev/null +++ b/instrumentation-api-semconv/src/main/java/io/opentelemetry/instrumentation/api/metrics/internal/DurationHistogramFactory.java @@ -0,0 +1,64 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.metrics.internal; + +import static java.util.Arrays.asList; +import static java.util.Collections.unmodifiableList; + +import io.opentelemetry.api.metrics.DoubleHistogramBuilder; +import io.opentelemetry.api.metrics.Meter; +import io.opentelemetry.extension.incubator.metrics.ExtendedDoubleHistogramBuilder; +import io.opentelemetry.instrumentation.api.internal.SemconvStability; +import java.util.List; +import java.util.concurrent.TimeUnit; + +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ +public final class DurationHistogramFactory { + public static final List DURATION_SECONDS_BUCKETS = + unmodifiableList( + asList( + 0.0, 0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1.0, 2.5, 5.0, 7.5, + 10.0)); + // we'll use the old unit if the old semconv is in use + private static final boolean useSeconds = + SemconvStability.emitStableHttpSemconv() && !SemconvStability.emitOldHttpSemconv(); + + private DurationHistogramFactory() {} + + public static DurationHistogram create(Meter meter, String name, String description) { + return create(meter.histogramBuilder(name).setDescription(description)); + } + + public static DurationHistogram create(DoubleHistogramBuilder builder) { + // don't set custom buckets if milliseconds are still used + if (useSeconds && builder instanceof ExtendedDoubleHistogramBuilder) { + ((ExtendedDoubleHistogramBuilder) builder) + .setAdvice(advice -> advice.setExplicitBucketBoundaries(DURATION_SECONDS_BUCKETS)); + } + return new DurationHistogram(builder.setUnit(useSeconds ? "s" : "ms").build()); + } + + static double toUnit(long duration, TimeUnit unit) { + return convertTimeUnit( + (double) duration, unit, useSeconds ? TimeUnit.SECONDS : TimeUnit.MILLISECONDS); + } + + private static double convertTimeUnit(double amount, TimeUnit from, TimeUnit to) { + // if the same unit is passed, avoid the conversion + if (from == to) { + return amount; + } + // is from or to the larger unit? + if (from.ordinal() < to.ordinal()) { // from is smaller + return amount / from.convert(1, to); + } else { + return amount * to.convert(1, from); + } + } +} diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetricsStableSemconvTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetricsStableSemconvTest.java index 97e9f3a26af9..0d56c5f8a836 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetricsStableSemconvTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetricsStableSemconvTest.java @@ -17,6 +17,7 @@ import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogramFactory; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; import java.util.concurrent.TimeUnit; @@ -25,7 +26,7 @@ class HttpClientMetricsStableSemconvTest { static final double[] DURATION_BUCKETS = - HttpMetricsUtil.DURATION_SECONDS_BUCKETS.stream().mapToDouble(d -> d).toArray(); + DurationHistogramFactory.DURATION_SECONDS_BUCKETS.stream().mapToDouble(d -> d).toArray(); @Test void collectsMetrics() { diff --git a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetricsStableSemconvTest.java b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetricsStableSemconvTest.java index c1ee03986b4b..d7c06d28267c 100644 --- a/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetricsStableSemconvTest.java +++ b/instrumentation-api-semconv/src/testStableHttpSemconv/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetricsStableSemconvTest.java @@ -17,6 +17,7 @@ import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; import io.opentelemetry.instrumentation.api.instrumenter.network.internal.NetworkAttributes; import io.opentelemetry.instrumentation.api.instrumenter.url.internal.UrlAttributes; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogramFactory; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; @@ -26,7 +27,7 @@ class HttpServerMetricsStableSemconvTest { static final double[] DURATION_BUCKETS = - HttpMetricsUtil.DURATION_SECONDS_BUCKETS.stream().mapToDouble(d -> d).toArray(); + DurationHistogramFactory.DURATION_SECONDS_BUCKETS.stream().mapToDouble(d -> d).toArray(); @Test void collectsMetrics() { diff --git a/instrumentation/dropwizard/dropwizard-metrics-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/dropwizardmetrics/DropwizardMetricsAdapter.java b/instrumentation/dropwizard/dropwizard-metrics-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/dropwizardmetrics/DropwizardMetricsAdapter.java index 61c01ef1c38f..69618191be20 100644 --- a/instrumentation/dropwizard/dropwizard-metrics-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/dropwizardmetrics/DropwizardMetricsAdapter.java +++ b/instrumentation/dropwizard/dropwizard-metrics-4.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/dropwizardmetrics/DropwizardMetricsAdapter.java @@ -12,11 +12,12 @@ import com.codahale.metrics.MetricRegistryListener; import com.codahale.metrics.Timer; import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.api.metrics.DoubleHistogram; import io.opentelemetry.api.metrics.LongCounter; import io.opentelemetry.api.metrics.LongHistogram; import io.opentelemetry.api.metrics.LongUpDownCounter; import io.opentelemetry.api.metrics.ObservableDoubleGauge; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogram; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogramFactory; import io.opentelemetry.instrumentation.api.util.VirtualField; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @@ -24,20 +25,18 @@ public final class DropwizardMetricsAdapter implements MetricRegistryListener { - private static final double NANOS_PER_MS = TimeUnit.MILLISECONDS.toNanos(1); - private static final VirtualField otelUpDownCounterField = VirtualField.find(Counter.class, LongUpDownCounter.class); private static final VirtualField otelHistogramField = VirtualField.find(Histogram.class, LongHistogram.class); private static final VirtualField otelCounterField = VirtualField.find(Meter.class, LongCounter.class); - private static final VirtualField otelDoubleHistogramField = - VirtualField.find(Timer.class, DoubleHistogram.class); + private static final VirtualField otelDurationHistogramField = + VirtualField.find(Timer.class, DurationHistogram.class); private final io.opentelemetry.api.metrics.Meter otelMeter; - private final Map otelDoubleHistograms = new ConcurrentHashMap<>(); + private final Map otelDurationHistograms = new ConcurrentHashMap<>(); private final Map otelCounters = new ConcurrentHashMap<>(); private final Map otelHistograms = new ConcurrentHashMap<>(); private final Map otelUpDownCounters = new ConcurrentHashMap<>(); @@ -150,25 +149,25 @@ public void meterMark(Meter dropwizardMeter, long increment) { @Override public void onTimerAdded(String name, Timer dropwizardTimer) { dropwizardTimers.put(name, dropwizardTimer); - DoubleHistogram otelHistogram = - otelDoubleHistograms.computeIfAbsent( - name, n -> otelMeter.histogramBuilder(n).setUnit("ms").build()); - otelDoubleHistogramField.set(dropwizardTimer, otelHistogram); + DurationHistogram otelHistogram = + otelDurationHistograms.computeIfAbsent( + name, n -> DurationHistogramFactory.create(otelMeter.histogramBuilder(n))); + otelDurationHistogramField.set(dropwizardTimer, otelHistogram); } @Override public void onTimerRemoved(String name) { Timer dropwizardTimer = dropwizardTimers.remove(name); - otelDoubleHistograms.remove(name); + otelDurationHistograms.remove(name); if (dropwizardTimer != null) { - otelDoubleHistogramField.set(dropwizardTimer, null); + otelDurationHistogramField.set(dropwizardTimer, null); } } public void timerUpdate(Timer dropwizardTimer, long nanos) { - DoubleHistogram otelHistogram = otelDoubleHistogramField.get(dropwizardTimer); + DurationHistogram otelHistogram = otelDurationHistogramField.get(dropwizardTimer); if (otelHistogram != null) { - otelHistogram.record(nanos / NANOS_PER_MS); + otelHistogram.record(nanos, TimeUnit.NANOSECONDS); } } } diff --git a/instrumentation/hikaricp-3.0/library/src/main/java/io/opentelemetry/instrumentation/hikaricp/v3_0/OpenTelemetryMetricsTracker.java b/instrumentation/hikaricp-3.0/library/src/main/java/io/opentelemetry/instrumentation/hikaricp/v3_0/OpenTelemetryMetricsTracker.java index d670a6548e31..52cda29c835f 100644 --- a/instrumentation/hikaricp-3.0/library/src/main/java/io/opentelemetry/instrumentation/hikaricp/v3_0/OpenTelemetryMetricsTracker.java +++ b/instrumentation/hikaricp-3.0/library/src/main/java/io/opentelemetry/instrumentation/hikaricp/v3_0/OpenTelemetryMetricsTracker.java @@ -8,30 +8,28 @@ import com.zaxxer.hikari.metrics.IMetricsTracker; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.metrics.BatchCallback; -import io.opentelemetry.api.metrics.DoubleHistogram; import io.opentelemetry.api.metrics.LongCounter; +import io.opentelemetry.instrumentation.api.metrics.internal.DurationHistogram; import java.util.concurrent.TimeUnit; final class OpenTelemetryMetricsTracker implements IMetricsTracker { - private static final double NANOS_PER_MS = TimeUnit.MILLISECONDS.toNanos(1); - private final IMetricsTracker userMetricsTracker; private final BatchCallback callback; private final LongCounter timeouts; - private final DoubleHistogram createTime; - private final DoubleHistogram waitTime; - private final DoubleHistogram useTime; + private final DurationHistogram createTime; + private final DurationHistogram waitTime; + private final DurationHistogram useTime; private final Attributes attributes; OpenTelemetryMetricsTracker( IMetricsTracker userMetricsTracker, BatchCallback callback, LongCounter timeouts, - DoubleHistogram createTime, - DoubleHistogram waitTime, - DoubleHistogram useTime, + DurationHistogram createTime, + DurationHistogram waitTime, + DurationHistogram useTime, Attributes attributes) { this.userMetricsTracker = userMetricsTracker; this.callback = callback; @@ -44,20 +42,19 @@ final class OpenTelemetryMetricsTracker implements IMetricsTracker { @Override public void recordConnectionCreatedMillis(long connectionCreatedMillis) { - createTime.record((double) connectionCreatedMillis, attributes); + createTime.record(connectionCreatedMillis, TimeUnit.MILLISECONDS, attributes); userMetricsTracker.recordConnectionCreatedMillis(connectionCreatedMillis); } @Override public void recordConnectionAcquiredNanos(long elapsedAcquiredNanos) { - double millis = elapsedAcquiredNanos / NANOS_PER_MS; - waitTime.record(millis, attributes); + waitTime.record(elapsedAcquiredNanos, TimeUnit.NANOSECONDS, attributes); userMetricsTracker.recordConnectionAcquiredNanos(elapsedAcquiredNanos); } @Override public void recordConnectionUsageMillis(long elapsedBorrowedMillis) { - useTime.record((double) elapsedBorrowedMillis, attributes); + useTime.record(elapsedBorrowedMillis, TimeUnit.MILLISECONDS, attributes); userMetricsTracker.recordConnectionUsageMillis(elapsedBorrowedMillis); }