diff --git a/instrumentation/runtime-metrics/library/build.gradle.kts b/instrumentation/runtime-metrics/library/build.gradle.kts index 34d3651cdc..55de74a17e 100644 --- a/instrumentation/runtime-metrics/library/build.gradle.kts +++ b/instrumentation/runtime-metrics/library/build.gradle.kts @@ -3,6 +3,8 @@ plugins { } dependencies { + implementation(project(":instrumentation-api")) + testImplementation("io.opentelemetry:opentelemetry-sdk-metrics") testImplementation(project(":testing-common")) } diff --git a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/BufferPools.java b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/BufferPools.java index 0a7c4c806e..b754797dc2 100644 --- a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/BufferPools.java +++ b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/BufferPools.java @@ -39,10 +39,14 @@ public final class BufferPools { /** Register observers for java runtime buffer pool metrics. */ public static void registerObservers(OpenTelemetry openTelemetry) { - List bufferBeans = ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class); - Meter meter = openTelemetry.getMeter("io.opentelemetry.runtime-metrics"); + registerObservers(openTelemetry, bufferBeans); + } + + // Visible for testing + static void registerObservers(OpenTelemetry openTelemetry, List bufferBeans) { + Meter meter = RuntimeMetricsUtil.getMeter(openTelemetry); meter .upDownCounterBuilder("process.runtime.jvm.buffer.usage") @@ -63,6 +67,7 @@ public final class BufferPools { .buildWithCallback(callback(bufferBeans, BufferPoolMXBean::getCount)); } + // Visible for testing static Consumer callback( List bufferPools, Function extractor) { List attributeSets = new ArrayList<>(bufferPools.size()); diff --git a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Classes.java b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Classes.java index 334c5b169c..bf04a8dd00 100644 --- a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Classes.java +++ b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Classes.java @@ -39,7 +39,7 @@ public final class Classes { // Visible for testing void registerObservers(OpenTelemetry openTelemetry, ClassLoadingMXBean classBean) { - Meter meter = openTelemetry.getMeter("io.opentelemetry.runtime-metrics"); + Meter meter = RuntimeMetricsUtil.getMeter(openTelemetry); meter .counterBuilder("process.runtime.jvm.classes.loaded") diff --git a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Cpu.java b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Cpu.java index ba2be73d20..182ae9a447 100644 --- a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Cpu.java +++ b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Cpu.java @@ -80,7 +80,7 @@ public final class Cpu { OperatingSystemMXBean osBean, @Nullable Supplier systemCpuUsage, @Nullable Supplier processCpuUsage) { - Meter meter = openTelemetry.getMeter("io.opentelemetry.runtime-metrics"); + Meter meter = RuntimeMetricsUtil.getMeter(openTelemetry); meter .gaugeBuilder("process.runtime.jvm.system.cpu.load_1m") diff --git a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/GarbageCollector.java b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/GarbageCollector.java index 80352ef4cb..5556060b89 100644 --- a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/GarbageCollector.java +++ b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/GarbageCollector.java @@ -36,7 +36,7 @@ public final class GarbageCollector { /** Register observers for java runtime garbage collector metrics. */ public static void registerObservers(OpenTelemetry openTelemetry) { List garbageCollectors = ManagementFactory.getGarbageCollectorMXBeans(); - Meter meter = openTelemetry.getMeterProvider().get(GarbageCollector.class.getName()); + Meter meter = RuntimeMetricsUtil.getMeter(openTelemetry); List labelSets = new ArrayList<>(garbageCollectors.size()); for (GarbageCollectorMXBean gc : garbageCollectors) { labelSets.add(Attributes.of(GC_KEY, gc.getName())); diff --git a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/MemoryPools.java b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/MemoryPools.java index 90c1394d66..44b83c66c4 100644 --- a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/MemoryPools.java +++ b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/MemoryPools.java @@ -50,8 +50,12 @@ public final class MemoryPools { /** Register observers for java runtime memory metrics. */ public static void registerObservers(OpenTelemetry openTelemetry) { - List poolBeans = ManagementFactory.getMemoryPoolMXBeans(); - Meter meter = openTelemetry.getMeter("io.opentelemetry.runtime-metrics"); + registerObservers(openTelemetry, ManagementFactory.getMemoryPoolMXBeans()); + } + + // Visible for testing + static void registerObservers(OpenTelemetry openTelemetry, List poolBeans) { + Meter meter = RuntimeMetricsUtil.getMeter(openTelemetry); meter .upDownCounterBuilder("process.runtime.jvm.memory.usage") diff --git a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/RuntimeMetricsUtil.java b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/RuntimeMetricsUtil.java new file mode 100644 index 0000000000..f144dce928 --- /dev/null +++ b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/RuntimeMetricsUtil.java @@ -0,0 +1,31 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.runtimemetrics; + +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.api.metrics.Meter; +import io.opentelemetry.api.metrics.MeterBuilder; +import io.opentelemetry.instrumentation.api.internal.EmbeddedInstrumentationProperties; +import javax.annotation.Nullable; + +class RuntimeMetricsUtil { + + private static final String INSTRUMENTATION_NAME = "io.opentelemetry.runtime-metrics"; + + @Nullable + private static final String INSTRUMENTATION_VERSION = + EmbeddedInstrumentationProperties.findVersion(INSTRUMENTATION_NAME); + + static Meter getMeter(OpenTelemetry openTelemetry) { + MeterBuilder meterBuilder = openTelemetry.meterBuilder(INSTRUMENTATION_NAME); + if (INSTRUMENTATION_VERSION != null) { + meterBuilder.setInstrumentationVersion(INSTRUMENTATION_VERSION); + } + return meterBuilder.build(); + } + + private RuntimeMetricsUtil() {} +} diff --git a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Threads.java b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Threads.java index 9caa2a2355..891e6772f3 100644 --- a/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Threads.java +++ b/instrumentation/runtime-metrics/library/src/main/java/io/opentelemetry/instrumentation/runtimemetrics/Threads.java @@ -42,7 +42,7 @@ public final class Threads { // Visible for testing void registerObservers(OpenTelemetry openTelemetry, ThreadMXBean threadBean) { - Meter meter = openTelemetry.getMeter("io.opentelemetry.runtime-metrics"); + Meter meter = RuntimeMetricsUtil.getMeter(openTelemetry); meter .upDownCounterBuilder("process.runtime.jvm.threads.count") diff --git a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/BufferPoolsTest.java b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/BufferPoolsTest.java index 8e62a0250c..b4dc703eca 100644 --- a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/BufferPoolsTest.java +++ b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/BufferPoolsTest.java @@ -5,14 +5,19 @@ package io.opentelemetry.instrumentation.runtimemetrics; +import static io.opentelemetry.instrumentation.runtimemetrics.ScopeUtil.EXPECTED_SCOPE; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.metrics.ObservableLongMeasurement; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.LibraryInstrumentationExtension; import java.lang.management.BufferPoolMXBean; import java.util.Arrays; import java.util.List; @@ -20,12 +25,17 @@ import java.util.function.Consumer; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.extension.RegisterExtension; import org.mockito.Mock; import org.mockito.Spy; import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) public class BufferPoolsTest { + + @RegisterExtension + static final InstrumentationExtension testing = LibraryInstrumentationExtension.create(); + @Spy private ObservableLongMeasurement measurement; @Mock private BufferPoolMXBean bufferPoolBean; private List beans; @@ -36,6 +46,74 @@ public class BufferPoolsTest { beans = Arrays.asList(bufferPoolBean); } + @Test + void registerObservers() { + when(bufferPoolBean.getMemoryUsed()).thenReturn(10L); + when(bufferPoolBean.getTotalCapacity()).thenReturn(11L); + when(bufferPoolBean.getCount()).thenReturn(12L); + + BufferPools.registerObservers(testing.getOpenTelemetry(), beans); + + testing.waitAndAssertMetrics( + "io.opentelemetry.runtime-metrics", + "process.runtime.jvm.buffer.usage", + metrics -> + metrics.anySatisfy( + metricData -> + assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) + .hasDescription( + "Memory that the Java virtual machine is using for this buffer pool") + .hasUnit("By") + .hasLongSumSatisfying( + sum -> + sum.hasPointsSatisfying( + point -> + point + .hasValue(10) + .hasAttribute( + AttributeKey.stringKey("pool"), + "buffer_pool_1"))))); + testing.waitAndAssertMetrics( + "io.opentelemetry.runtime-metrics", + "process.runtime.jvm.buffer.limit", + metrics -> + metrics.anySatisfy( + metricData -> + assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) + .hasDescription("Total capacity of the buffers in this pool") + .hasUnit("By") + .hasLongSumSatisfying( + sum -> + sum.hasPointsSatisfying( + point -> + point + .hasValue(11) + .hasAttribute( + AttributeKey.stringKey("pool"), + "buffer_pool_1"))))); + testing.waitAndAssertMetrics( + "io.opentelemetry.runtime-metrics", + "process.runtime.jvm.buffer.count", + metrics -> + metrics.anySatisfy( + metricData -> + assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) + .hasDescription("The number of buffers in the pool") + .hasUnit("buffers") + .hasLongSumSatisfying( + sum -> + sum.hasPointsSatisfying( + point -> + point + .hasValue(12) + .hasAttribute( + AttributeKey.stringKey("pool"), + "buffer_pool_1"))))); + } + @Test void callback_Records() { when(bufferPoolBean.getMemoryUsed()).thenReturn(1L); diff --git a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ClassesTest.java b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ClassesTest.java index 8cdbc2fd93..3dd9fb3ba6 100644 --- a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ClassesTest.java +++ b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ClassesTest.java @@ -5,6 +5,7 @@ package io.opentelemetry.instrumentation.runtimemetrics; +import static io.opentelemetry.instrumentation.runtimemetrics.ScopeUtil.EXPECTED_SCOPE; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; import static org.mockito.Mockito.when; @@ -41,6 +42,7 @@ class ClassesTest { metrics.anySatisfy( metricData -> assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) .hasDescription("Number of classes loaded since JVM start") .hasUnit("1") .hasLongSumSatisfying( @@ -56,6 +58,7 @@ class ClassesTest { metrics.anySatisfy( metricData -> assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) .hasDescription("Number of classes unloaded since JVM start") .hasUnit("1") .hasLongSumSatisfying( @@ -71,6 +74,7 @@ class ClassesTest { metrics.anySatisfy( metricData -> assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) .hasDescription("Number of classes currently loaded") .hasUnit("1") .hasLongSumSatisfying( diff --git a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/CpuTest.java b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/CpuTest.java index 91ce9c3005..912172616b 100644 --- a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/CpuTest.java +++ b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/CpuTest.java @@ -5,6 +5,7 @@ package io.opentelemetry.instrumentation.runtimemetrics; +import static io.opentelemetry.instrumentation.runtimemetrics.ScopeUtil.EXPECTED_SCOPE; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; import static org.mockito.Mockito.when; @@ -42,6 +43,7 @@ class CpuTest { metrics.anySatisfy( metricData -> assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) .hasDescription("Average CPU load of the whole system for the last minute") .hasUnit("1") .hasDoubleGaugeSatisfying( @@ -53,6 +55,7 @@ class CpuTest { metrics.anySatisfy( metricData -> assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) .hasDescription("Recent cpu utilization for the whole system") .hasUnit("1") .hasDoubleGaugeSatisfying( @@ -64,6 +67,7 @@ class CpuTest { metrics.anySatisfy( metricData -> assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) .hasDescription("Recent cpu utilization for the process") .hasUnit("1") .hasDoubleGaugeSatisfying( diff --git a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/MemoryPoolsTest.java b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/MemoryPoolsTest.java index cac71df834..a58bfb6eca 100644 --- a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/MemoryPoolsTest.java +++ b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/MemoryPoolsTest.java @@ -5,14 +5,19 @@ package io.opentelemetry.instrumentation.runtimemetrics; +import static io.opentelemetry.instrumentation.runtimemetrics.ScopeUtil.EXPECTED_SCOPE; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.metrics.ObservableLongMeasurement; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.LibraryInstrumentationExtension; import java.lang.management.MemoryPoolMXBean; import java.lang.management.MemoryType; import java.lang.management.MemoryUsage; @@ -22,6 +27,7 @@ import java.util.function.Consumer; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.extension.RegisterExtension; import org.mockito.Mock; import org.mockito.Spy; import org.mockito.junit.jupiter.MockitoExtension; @@ -29,6 +35,9 @@ import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) class MemoryPoolsTest { + @RegisterExtension + static final InstrumentationExtension testing = LibraryInstrumentationExtension.create(); + @Spy private ObservableLongMeasurement measurement; @Mock private MemoryPoolMXBean heapPoolBean; @@ -50,6 +59,125 @@ class MemoryPoolsTest { beans = Arrays.asList(heapPoolBean, nonHeapPoolBean); } + @Test + void registerObservers() { + when(heapPoolUsage.getInit()).thenReturn(10L); + when(heapPoolUsage.getUsed()).thenReturn(11L); + when(heapPoolUsage.getCommitted()).thenReturn(12L); + when(heapPoolUsage.getMax()).thenReturn(13L); + when(nonHeapUsage.getInit()).thenReturn(14L); + when(nonHeapUsage.getUsed()).thenReturn(15L); + when(nonHeapUsage.getCommitted()).thenReturn(16L); + when(nonHeapUsage.getMax()).thenReturn(17L); + + MemoryPools.registerObservers(testing.getOpenTelemetry(), beans); + + testing.waitAndAssertMetrics( + "io.opentelemetry.runtime-metrics", + "process.runtime.jvm.memory.init", + metrics -> + metrics.anySatisfy( + metricData -> + assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) + .hasDescription("Measure of initial memory requested") + .hasUnit("By") + .hasLongSumSatisfying( + sum -> + sum.hasPointsSatisfying( + point -> + point + .hasValue(10) + .hasAttribute( + AttributeKey.stringKey("pool"), "heap_pool") + .hasAttribute(AttributeKey.stringKey("type"), "heap"), + point -> + point + .hasValue(14) + .hasAttribute( + AttributeKey.stringKey("pool"), "non_heap_pool") + .hasAttribute( + AttributeKey.stringKey("type"), "non_heap"))))); + testing.waitAndAssertMetrics( + "io.opentelemetry.runtime-metrics", + "process.runtime.jvm.memory.usage", + metrics -> + metrics.anySatisfy( + metricData -> + assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) + .hasDescription("Measure of memory used") + .hasUnit("By") + .hasLongSumSatisfying( + sum -> + sum.hasPointsSatisfying( + point -> + point + .hasValue(11) + .hasAttribute( + AttributeKey.stringKey("pool"), "heap_pool") + .hasAttribute(AttributeKey.stringKey("type"), "heap"), + point -> + point + .hasValue(15) + .hasAttribute( + AttributeKey.stringKey("pool"), "non_heap_pool") + .hasAttribute( + AttributeKey.stringKey("type"), "non_heap"))))); + testing.waitAndAssertMetrics( + "io.opentelemetry.runtime-metrics", + "process.runtime.jvm.memory.committed", + metrics -> + metrics.anySatisfy( + metricData -> + assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) + .hasDescription("Measure of memory committed") + .hasUnit("By") + .hasLongSumSatisfying( + sum -> + sum.hasPointsSatisfying( + point -> + point + .hasValue(12) + .hasAttribute( + AttributeKey.stringKey("pool"), "heap_pool") + .hasAttribute(AttributeKey.stringKey("type"), "heap"), + point -> + point + .hasValue(16) + .hasAttribute( + AttributeKey.stringKey("pool"), "non_heap_pool") + .hasAttribute( + AttributeKey.stringKey("type"), "non_heap"))))); + testing.waitAndAssertMetrics( + "io.opentelemetry.runtime-metrics", + "process.runtime.jvm.memory.limit", + metrics -> + metrics.anySatisfy( + metricData -> + assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) + .hasDescription("Measure of max obtainable memory") + .hasUnit("By") + .hasLongSumSatisfying( + sum -> + sum.hasPointsSatisfying( + point -> + point + .hasValue(13) + .hasAttribute( + AttributeKey.stringKey("pool"), "heap_pool") + .hasAttribute(AttributeKey.stringKey("type"), "heap"), + point -> + point + .hasValue(17) + .hasAttribute( + AttributeKey.stringKey("pool"), "non_heap_pool") + .hasAttribute( + AttributeKey.stringKey("type"), "non_heap"))))); + } + @Test void callback_Records() { when(heapPoolUsage.getUsed()).thenReturn(1L); diff --git a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ScopeUtil.java b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ScopeUtil.java new file mode 100644 index 0000000000..3f229de822 --- /dev/null +++ b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ScopeUtil.java @@ -0,0 +1,25 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.runtimemetrics; + +import io.opentelemetry.instrumentation.api.internal.EmbeddedInstrumentationProperties; +import io.opentelemetry.sdk.common.InstrumentationScopeInfo; +import java.util.Optional; + +class ScopeUtil { + + static final InstrumentationScopeInfo EXPECTED_SCOPE = + InstrumentationScopeInfo.builder("io.opentelemetry.runtime-metrics") + .setVersion( + Optional.ofNullable( + EmbeddedInstrumentationProperties.findVersion( + "io.opentelemetry.runtime-metrics")) + .orElseThrow( + () -> new IllegalStateException("Unable to find instrumentation version"))) + .build(); + + private ScopeUtil() {} +} diff --git a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ThreadsTest.java b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ThreadsTest.java index 9265c4cc9e..d9001f4db9 100644 --- a/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ThreadsTest.java +++ b/instrumentation/runtime-metrics/library/src/test/java/io/opentelemetry/instrumentation/runtimemetrics/ThreadsTest.java @@ -5,6 +5,7 @@ package io.opentelemetry.instrumentation.runtimemetrics; +import static io.opentelemetry.instrumentation.runtimemetrics.ScopeUtil.EXPECTED_SCOPE; import static io.opentelemetry.instrumentation.runtimemetrics.Threads.DAEMON; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo; @@ -41,6 +42,7 @@ class ThreadsTest { metrics.anySatisfy( metricData -> assertThat(metricData) + .hasInstrumentationScope(EXPECTED_SCOPE) .hasDescription("Number of executing threads") .hasUnit("1") .hasLongSumSatisfying(