use testing extension for metrics assertions

Author: SylvainJuge

instrumentation/jmx-metrics/library/src/test/java/io/opentelemetry/instrumentation/jmx/engine/MetricAggregationTest.java

@@ -6,22 +6,21 @@
 package io.opentelemetry.instrumentation.jmx.engine;
 
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
-import static org.assertj.core.groups.Tuple.tuple;
 import static org.junit.jupiter.params.ParameterizedInvocationConstants.ARGUMENTS_PLACEHOLDER;
 
 import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.api.common.Attributes;
-import io.opentelemetry.sdk.OpenTelemetrySdk;
-import io.opentelemetry.sdk.metrics.SdkMeterProvider;
-import io.opentelemetry.sdk.metrics.data.LongPointData;
-import io.opentelemetry.sdk.metrics.data.MetricData;
-import io.opentelemetry.sdk.metrics.data.PointData;
-import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader;
+import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
+import io.opentelemetry.instrumentation.testing.junit.LibraryInstrumentationExtension;
+import io.opentelemetry.sdk.testing.assertj.LongPointAssert;
+import io.opentelemetry.sdk.testing.assertj.MetricAssert;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
 import javax.annotation.Nullable;
 import javax.management.InstanceNotFoundException;
 import javax.management.MBeanRegistrationException;
@@ -32,7 +31,7 @@
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -58,6 +57,9 @@ public int getValue() {
     }
   }
 
+  @RegisterExtension
+  static final InstrumentationExtension testing = LibraryInstrumentationExtension.create();
+
   private static final String DOMAIN = "otel.jmx.test";
   private static MBeanServer theServer;
 
@@ -71,15 +73,6 @@ static void tearDown() {
     MBeanServerFactory.releaseMBeanServer(theServer);
   }
 
-  @BeforeEach
-  void before() {
-    reader = InMemoryMetricReader.createDelta();
-    sdk =
-        OpenTelemetrySdk.builder()
-            .setMeterProvider(SdkMeterProvider.builder().registerMetricReader(reader).build())
-            .build();
-  }
-
   @AfterEach
   void after() throws Exception {
     ObjectName objectName = new ObjectName(DOMAIN + ":type=" + Hello.class.getSimpleName() + ",*");
@@ -93,15 +86,8 @@ void after() throws Exception {
                 throw new RuntimeException(e);
               }
             });
-
-    if (sdk != null) {
-      sdk.getSdkMeterProvider().close();
-    }
   }
 
-  private InMemoryMetricReader reader;
-  private OpenTelemetrySdk sdk;
-
   private static ObjectName getObjectName(@Nullable String a, @Nullable String b)
       throws MalformedObjectNameException {
     StringBuilder parts = new StringBuilder();
@@ -126,8 +112,10 @@ void singleInstance(MetricInfo.Type metricType) throws Exception {
     ObjectName bean = getObjectName(null, null);
     theServer.registerMBean(new Hello(42), bean);
 
-    Collection<MetricData> data = testMetric(bean.toString(), Collections.emptyList(), metricType);
-    checkSingleValue(data, 42, metricType);
+    String metricName = generateMetricName(metricType);
+    startTestMetric(metricName, bean.toString(), Collections.emptyList(), metricType);
+    waitAndAssertMetric(
+        metricName, metricType, point -> point.hasValue(42).hasAttributes(Attributes.empty()));
   }
 
   @ParameterizedTest(name = ARGUMENTS_PLACEHOLDER)
@@ -137,14 +125,17 @@ void aggregateOneParam(MetricInfo.Type metricType) throws Exception {
     theServer.registerMBean(new Hello(37), getObjectName("value2", null));
 
     String bean = getObjectName("*", null).toString();
-    Collection<MetricData> data = testMetric(bean, Collections.emptyList(), metricType);
-    int expected = 79;
-    if (metricType == MetricInfo.Type.GAUGE) {
-      // last-value aggregation produces unpredictable result unless a single mbean instance is used
-      // test here is only used as a way to document behavior and should not be considered a feature
-      expected = 37;
-    }
-    checkSingleValue(data, expected, metricType);
+    String metricName = generateMetricName(metricType);
+    startTestMetric(metricName, bean, Collections.emptyList(), metricType);
+
+    // last-value aggregation produces an unpredictable result unless a single mbean instance is
+    // used
+    // test here is only used as a way to document behavior and should not be considered a feature
+    long expected = metricType == MetricInfo.Type.GAUGE ? 37 : 79;
+    waitAndAssertMetric(
+        metricName,
+        metricType,
+        point -> point.hasValue(expected).hasAttributes(Attributes.empty()));
   }
 
   @ParameterizedTest(name = ARGUMENTS_PLACEHOLDER)
@@ -156,15 +147,17 @@ void aggregateMultipleParams(MetricInfo.Type metricType) throws Exception {
     theServer.registerMBean(new Hello(4), getObjectName("4", "y"));
 
     String bean = getObjectName("*", "*").toString();
-    Collection<MetricData> data = testMetric(bean, Collections.emptyList(), metricType);
-
-    int expected = 10;
-    if (metricType == MetricInfo.Type.GAUGE) {
-      // last-value aggregation produces unpredictable result unless a single mbean instance is used
-      // test here is only used as a way to document behavior and should not be considered a feature
-      expected = 1;
-    }
-    checkSingleValue(data, expected, metricType);
+    String metricName = generateMetricName(metricType);
+    startTestMetric(metricName, bean, Collections.emptyList(), metricType);
+
+    // last-value aggregation produces an unpredictable result unless a single mbean instance is
+    // used
+    // test here is only used as a way to document behavior and should not be considered a feature
+    long expected = metricType == MetricInfo.Type.GAUGE ? 1 : 10;
+    waitAndAssertMetric(
+        metricName,
+        metricType,
+        point -> point.hasValue(expected).hasAttributes(Attributes.empty()));
   }
 
   @ParameterizedTest(name = ARGUMENTS_PLACEHOLDER)
@@ -181,44 +174,66 @@ void partialAggregateMultipleParams(MetricInfo.Type metricType) throws Exception
         Collections.singletonList(
             new MetricAttribute(
                 "test.metric.param", MetricAttributeExtractor.fromObjectNameParameter("b")));
-    Collection<MetricData> data = testMetric(bean, attributes, metricType);
-
-    assertThat(data)
-        .isNotEmpty()
-        .satisfiesExactly(
-            metric -> {
-              assertThat(metric.getName()).isEqualTo("test.metric");
-              AttributeKey<String> metricAttribute = AttributeKey.stringKey("test.metric.param");
-
-              if (metricType == MetricInfo.Type.GAUGE) {
-                // last-value aggregation produces unpredictable result unless a single mbean
-                // instance is used
-                // test here is only used as a way to document behavior and should not be considered
-                // a feature
-                assertThat(metric.getLongGaugeData().getPoints())
-                    .extracting(LongPointData::getValue, PointData::getAttributes)
-                    .containsExactlyInAnyOrder(
-                        tuple(4L, Attributes.of(metricAttribute, "y")),
-                        tuple(1L, Attributes.of(metricAttribute, "x")));
-              } else {
-                // sum aggregation
-                assertThat(metric.getLongSumData().getPoints())
-                    .extracting(LongPointData::getValue, PointData::getAttributes)
-                    .containsExactlyInAnyOrder(
-                        tuple(6L, Attributes.of(metricAttribute, "y")),
-                        tuple(4L, Attributes.of(metricAttribute, "x")));
-              }
-            });
+    String metricName = generateMetricName(metricType);
+    startTestMetric(metricName, bean, attributes, metricType);
+
+    AttributeKey<String> metricAttribute = AttributeKey.stringKey("test.metric.param");
+    if (metricType == MetricInfo.Type.GAUGE) {
+      waitAndAssertMetric(
+          metricName,
+          metricType,
+          point -> point.hasValue(1).hasAttribute(metricAttribute, "x"),
+          point -> point.hasValue(4).hasAttribute(metricAttribute, "y"));
+    } else {
+      waitAndAssertMetric(
+          metricName,
+          metricType,
+          point -> point.hasValue(4).hasAttribute(metricAttribute, "x"),
+          point -> point.hasValue(6).hasAttribute(metricAttribute, "y"));
+    }
+  }
+
+  private static final AtomicInteger metricCounter = new AtomicInteger(0);
+
+  private static String generateMetricName(MetricInfo.Type metricType) {
+    // generate a sequential metric name that prevents naming conflicts and unexpected behaviors
+    return "test.metric"
+        + metricCounter.incrementAndGet()
+        + "."
+        + metricType.name().toLowerCase(Locale.ROOT);
   }
 
-  private Collection<MetricData> testMetric(
-      String mbean, List<MetricAttribute> attributes, MetricInfo.Type metricType)
+  @SafeVarargs
+  @SuppressWarnings("varargs")
+  private static void waitAndAssertMetric(
+      String metricName, MetricInfo.Type metricType, Consumer<LongPointAssert>... pointAsserts) {
+
+    testing.waitAndAssertMetrics(
+        "io.opentelemetry.jmx",
+        metricName,
+        metrics ->
+            metrics.anySatisfy(
+                metricData -> {
+                  MetricAssert metricAssert =
+                      assertThat(metricData).hasDescription("description").hasUnit("1");
+                  if (metricType == MetricInfo.Type.GAUGE) {
+                    metricAssert.hasLongGaugeSatisfying(
+                        gauge -> gauge.hasPointsSatisfying(pointAsserts));
+                  } else {
+                    metricAssert.hasLongSumSatisfying(sum -> sum.hasPointsSatisfying(pointAsserts));
+                  }
+                }));
+  }
+
+  private static void startTestMetric(
+      String metricName, String mbean, List<MetricAttribute> attributes, MetricInfo.Type metricType)
       throws MalformedObjectNameException {
-    JmxMetricInsight metricInsight = JmxMetricInsight.createService(sdk, 0);
+    JmxMetricInsight metricInsight =
+        JmxMetricInsight.createService(testing.getOpenTelemetrySdk(), 0);
     MetricConfiguration metricConfiguration = new MetricConfiguration();
     List<MetricExtractor> extractors = new ArrayList<>();
 
-    MetricInfo metricInfo = new MetricInfo("test.metric", "description", null, "1", metricType);
+    MetricInfo metricInfo = new MetricInfo(metricName, "description", null, "1", metricType);
     BeanAttributeExtractor beanExtractor = BeanAttributeExtractor.fromName("Value");
     MetricExtractor extractor = new MetricExtractor(beanExtractor, metricInfo, attributes);
     extractors.add(extractor);
@@ -227,44 +242,5 @@ private Collection<MetricData> testMetric(
 
     metricConfiguration.addMetricDef(metricDef);
     metricInsight.startLocal(metricConfiguration);
-
-    return waitMetricsReceived();
-  }
-
-  private static void checkSingleValue(
-      Collection<MetricData> data, long expectedValue, MetricInfo.Type metricType) {
-    assertThat(data)
-        .isNotEmpty()
-        .satisfiesExactlyInAnyOrder(
-            metric -> {
-              assertThat(metric.getName()).isEqualTo("test.metric");
-
-              Collection<LongPointData> points;
-              if (metricType == MetricInfo.Type.GAUGE) {
-                points = metric.getLongGaugeData().getPoints();
-              } else {
-                points = metric.getLongSumData().getPoints();
-              }
-              assertThat(points)
-                  .extracting(LongPointData::getValue, PointData::getAttributes)
-                  .containsExactlyInAnyOrder(tuple(expectedValue, Attributes.empty()));
-            });
-  }
-
-  private Collection<MetricData> waitMetricsReceived() {
-    int retries = 100;
-    Collection<MetricData> data;
-    do {
-      try {
-        Thread.sleep(100);
-      } catch (InterruptedException e) {
-        throw new RuntimeException(e);
-      }
-      data = reader.collectAllMetrics();
-    } while (data.isEmpty() && retries-- > 0);
-    if (data.isEmpty()) {
-      throw new RuntimeException("timed out waiting for metrics received");
-    }
-    return data;
   }
 }