open-telemetry
/
opentelemetry-java-instrumentation
mirror of https://github.com/open-telemetry/opentelemetry-java-instrumentation.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update to OTel 1.14 (#5999) 

* Update to OTel 1.14

* Fix test

Co-authored-by: Trask Stalnaker <trask.stalnaker@gmail.com>
This commit is contained in:
Anuraag Agrawal 2022-05-11 06:23:56 +09:00 committed by GitHub
parent 25d929b5e7
commit d1ee692479
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 1065 additions and 1037 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dependencyManagement/build.gradle.kts
View File

@ -11,7 +11,7 @@ data class DependencySet(val group: String, val version: String, val modules: Li
val dependencyVersions = hashMapOf<String, String>() val dependencyVersions = hashMapOf<String, String>()
rootProject.extra["versions"] = dependencyVersions rootProject.extra["versions"] = dependencyVersions
val otelVersion = "1.13.0" val otelVersion = "1.14.0"
rootProject.extra["otelVersion"] = otelVersion rootProject.extra["otelVersion"] = otelVersion
// Need both BOM and groovy jars // Need both BOM and groovy jars

49
instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpClientMetricsTest.java
View File

@ -5,8 +5,8 @@
package io.opentelemetry.instrumentation.api.instrumenter.http; package io.opentelemetry.instrumentation.api.instrumenter.http;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.Span;
@ -17,6 +17,7 @@ import io.opentelemetry.context.Context;
import io.opentelemetry.instrumentation.api.instrumenter.RequestListener; import io.opentelemetry.instrumentation.api.instrumenter.RequestListener;
import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.metrics.SdkMeterProvider;
import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader;
import io.opentelemetry.semconv.trace.attributes.SemanticAttributes;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
@ -70,42 +71,40 @@ class HttpClientMetricsTest {
listener.onEnd(context1, responseAttributes, nanos(250)); listener.onEnd(context1, responseAttributes, nanos(250));
assertThat(metricReader.collectAllMetrics()) assertThat(metricReader.collectAllMetrics())
.hasSize(1) .satisfiesExactlyInAnyOrder(
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("http.client.duration") .hasName("http.client.duration")
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> { point ->
assertThat(point) point
.hasSum(150 /* millis */) .hasSum(150 /* millis */)
.attributes() .hasAttributesSatisfying(
.containsOnly( equalTo(SemanticAttributes.NET_PEER_NAME, "localhost"),
attributeEntry("net.peer.name", "localhost"), equalTo(SemanticAttributes.NET_PEER_PORT, 1234),
attributeEntry("net.peer.port", 1234), equalTo(SemanticAttributes.HTTP_METHOD, "GET"),
attributeEntry("http.method", "GET"), equalTo(SemanticAttributes.HTTP_FLAVOR, "2.0"),
attributeEntry("http.flavor", "2.0"), equalTo(SemanticAttributes.HTTP_STATUS_CODE, 200))
attributeEntry("http.status_code", 200)); .hasExemplarsSatisfying(
assertThat(point).exemplars().hasSize(1); exemplar ->
assertThat(point.getExemplars().get(0)) exemplar
.hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00")
.hasSpanId("090a0b0c0d0e0f00"); .hasSpanId("090a0b0c0d0e0f00")))));
}));
listener.onEnd(context2, responseAttributes, nanos(300)); listener.onEnd(context2, responseAttributes, nanos(300));
assertThat(metricReader.collectAllMetrics()) assertThat(metricReader.collectAllMetrics())
.hasSize(1) .satisfiesExactlyInAnyOrder(
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("http.client.duration") .hasName("http.client.duration")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly(point -> assertThat(point).hasSum(300 /* millis */))); histogram.hasPointsSatisfying(
point -> point.hasSum(300 /* millis */))));
} }
private static long nanos(int millis) { private static long nanos(int millis) {

117
instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpServerMetricsTest.java
View File

@ -5,8 +5,8 @@
package io.opentelemetry.instrumentation.api.instrumenter.http; package io.opentelemetry.instrumentation.api.instrumenter.http;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.Span;
@ -17,6 +17,7 @@ import io.opentelemetry.context.Context;
import io.opentelemetry.instrumentation.api.instrumenter.RequestListener; import io.opentelemetry.instrumentation.api.instrumenter.RequestListener;
import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.metrics.SdkMeterProvider;
import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader;
import io.opentelemetry.semconv.trace.attributes.SemanticAttributes;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
@ -60,96 +61,86 @@ class HttpServerMetricsTest {
Context context1 = listener.onStart(parent, requestAttributes, nanos(100)); Context context1 = listener.onStart(parent, requestAttributes, nanos(100));
assertThat(metricReader.collectAllMetrics()) assertThat(metricReader.collectAllMetrics())
.hasSize(1) .satisfiesExactlyInAnyOrder(
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("http.server.active_requests") .hasName("http.server.active_requests")
.hasDescription( .hasDescription(
"The number of concurrent HTTP requests that are currently in-flight") "The number of concurrent HTTP requests that are currently in-flight")
.hasUnit("requests") .hasUnit("requests")
.hasLongSum() .hasLongSumSatisfying(
.points() sum ->
.satisfiesExactly( sum.hasPointsSatisfying(
point -> { point ->
assertThat(point) point
.hasValue(1) .hasValue(1)
.attributes() .hasAttributesSatisfying(
.containsOnly( equalTo(SemanticAttributes.HTTP_HOST, "host"),
attributeEntry("http.host", "host"), equalTo(SemanticAttributes.HTTP_METHOD, "GET"),
attributeEntry("http.method", "GET"), equalTo(SemanticAttributes.HTTP_SCHEME, "https"))
attributeEntry("http.scheme", "https")); .hasExemplarsSatisfying(
assertThat(point).exemplars().hasSize(1); exemplar ->
assertThat(point.getExemplars().get(0)) exemplar
.hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00")
.hasSpanId("090a0b0c0d0e0f00"); .hasSpanId("090a0b0c0d0e0f00")))));
}));
Context context2 = listener.onStart(Context.root(), requestAttributes, nanos(150)); Context context2 = listener.onStart(Context.root(), requestAttributes, nanos(150));
assertThat(metricReader.collectAllMetrics()) assertThat(metricReader.collectAllMetrics())
.hasSize(1) .satisfiesExactlyInAnyOrder(
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("http.server.active_requests") .hasName("http.server.active_requests")
.hasLongSum() .hasLongSumSatisfying(
.points() sum -> sum.hasPointsSatisfying(point -> point.hasValue(2))));
.satisfiesExactly(point -> assertThat(point).hasValue(2)));
listener.onEnd(context1, responseAttributes, nanos(250)); listener.onEnd(context1, responseAttributes, nanos(250));
assertThat(metricReader.collectAllMetrics()) assertThat(metricReader.collectAllMetrics())
.hasSize(2) .satisfiesExactlyInAnyOrder(
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("http.server.active_requests") .hasName("http.server.active_requests")
.hasLongSum() .hasLongSumSatisfying(
.points() sum -> sum.hasPointsSatisfying(point -> point.hasValue(1))),
.satisfiesExactly(point -> assertThat(point).hasValue(1)))
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("http.server.duration") .hasName("http.server.duration")
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> { point ->
assertThat(point) point
.hasSum(150 /* millis */) .hasSum(150 /* millis */)
.attributes() .hasAttributesSatisfying(
.containsOnly( equalTo(SemanticAttributes.HTTP_SCHEME, "https"),
attributeEntry("http.scheme", "https"), equalTo(SemanticAttributes.HTTP_HOST, "host"),
attributeEntry("http.host", "host"), equalTo(SemanticAttributes.HTTP_METHOD, "GET"),
attributeEntry("http.method", "GET"), equalTo(SemanticAttributes.HTTP_STATUS_CODE, 200),
attributeEntry("http.status_code", 200), equalTo(SemanticAttributes.HTTP_FLAVOR, "2.0"))
attributeEntry("http.flavor", "2.0")); .hasExemplarsSatisfying(
assertThat(point).exemplars().hasSize(1); exemplar ->
assertThat(point.getExemplars().get(0)) exemplar
.hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00")
.hasSpanId("090a0b0c0d0e0f00"); .hasSpanId("090a0b0c0d0e0f00")))));
}));
listener.onEnd(context2, responseAttributes, nanos(300)); listener.onEnd(context2, responseAttributes, nanos(300));
assertThat(metricReader.collectAllMetrics()) assertThat(metricReader.collectAllMetrics())
.hasSize(2) .satisfiesExactlyInAnyOrder(
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("http.server.active_requests") .hasName("http.server.active_requests")
.hasLongSum() .hasLongSumSatisfying(
.points() sum -> sum.hasPointsSatisfying(point -> point.hasValue(0))),
.satisfiesExactly(point -> assertThat(point).hasValue(0)))
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("http.server.duration") .hasName("http.server.duration")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly(point -> assertThat(point).hasSum(300 /* millis */))); histogram.hasPointsSatisfying(
point -> point.hasSum(300 /* millis */))));
} }
@Test @Test
@ -179,17 +170,17 @@ class HttpServerMetricsTest {
assertThat(metric) assertThat(metric)
.hasName("http.server.duration") .hasName("http.server.duration")
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasSum(100 /* millis */) .hasSum(100 /* millis */)
.attributes() .hasAttributesSatisfying(
.containsOnly( equalTo(SemanticAttributes.HTTP_SCHEME, "https"),
attributeEntry("http.scheme", "https"), equalTo(SemanticAttributes.HTTP_HOST, "host"),
attributeEntry("http.host", "host"), equalTo(
attributeEntry("http.route", "/test/{id}")))); SemanticAttributes.HTTP_ROUTE, "/test/{id}")))));
} }
private static long nanos(int millis) { private static long nanos(int millis) {

74
instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcClientMetricsTest.java
View File

@ -5,8 +5,8 @@
package io.opentelemetry.instrumentation.api.instrumenter.rpc; package io.opentelemetry.instrumentation.api.instrumenter.rpc;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.Span;
@ -74,56 +74,56 @@ class RpcClientMetricsTest {
listener.onEnd(context1, responseAttributes1, nanos(250)); listener.onEnd(context1, responseAttributes1, nanos(250));
assertThat(metricReader.collectAllMetrics()) assertThat(metricReader.collectAllMetrics())
.hasSize(1) .satisfiesExactlyInAnyOrder(
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("rpc.client.duration") .hasName("rpc.client.duration")
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> { point ->
assertThat(point) point
.hasSum(150 /* millis */) .hasSum(150 /* millis */)
.attributes() .hasAttributesSatisfying(
.containsOnly( equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"),
attributeEntry("rpc.system", "grpc"), equalTo(
attributeEntry("rpc.service", "myservice.EchoService"), SemanticAttributes.RPC_SERVICE,
attributeEntry("rpc.method", "exampleMethod"), "myservice.EchoService"),
attributeEntry("net.peer.name", "example.com"), equalTo(SemanticAttributes.RPC_METHOD, "exampleMethod"),
attributeEntry("net.peer.port", 8080), equalTo(
attributeEntry("net.transport", "ip_tcp")); SemanticAttributes.NET_PEER_NAME, "example.com"),
assertThat(point).exemplars().hasSize(1); equalTo(SemanticAttributes.NET_PEER_PORT, 8080),
assertThat(point.getExemplars().get(0)) equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"))
.hasExemplarsSatisfying(
exemplar ->
exemplar
.hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00")
.hasSpanId("090a0b0c0d0e0f00"); .hasSpanId("090a0b0c0d0e0f00")))));
}));
listener.onEnd(context2, responseAttributes2, nanos(300)); listener.onEnd(context2, responseAttributes2, nanos(300));
assertThat(metricReader.collectAllMetrics()) assertThat(metricReader.collectAllMetrics())
.hasSize(1) .satisfiesExactlyInAnyOrder(
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("rpc.client.duration") .hasName("rpc.client.duration")
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> { point ->
assertThat(point) point
.hasSum(150 /* millis */) .hasSum(150 /* millis */)
.attributes() .hasAttributesSatisfying(
.containsOnly( equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"),
attributeEntry("rpc.system", "grpc"), equalTo(
attributeEntry("rpc.service", "myservice.EchoService"), SemanticAttributes.RPC_SERVICE,
attributeEntry("rpc.method", "exampleMethod"), "myservice.EchoService"),
attributeEntry("net.peer.ip", "127.0.0.1"), equalTo(SemanticAttributes.RPC_METHOD, "exampleMethod"),
attributeEntry("net.peer.port", 8080), equalTo(SemanticAttributes.NET_PEER_IP, "127.0.0.1"),
attributeEntry("net.transport", "ip_tcp")); equalTo(SemanticAttributes.NET_PEER_PORT, 8080),
})); equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp")))));
} }
private static long nanos(int millis) { private static long nanos(int millis) {

70
instrumentation-api-semconv/src/test/java/io/opentelemetry/instrumentation/api/instrumenter/rpc/RpcServerMetricsTest.java
View File

@ -5,8 +5,8 @@
package io.opentelemetry.instrumentation.api.instrumenter.rpc; package io.opentelemetry.instrumentation.api.instrumenter.rpc;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.Span;
@ -74,54 +74,54 @@ class RpcServerMetricsTest {
listener.onEnd(context1, responseAttributes1, nanos(250)); listener.onEnd(context1, responseAttributes1, nanos(250));
assertThat(metricReader.collectAllMetrics()) assertThat(metricReader.collectAllMetrics())
.hasSize(1) .satisfiesExactlyInAnyOrder(
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("rpc.server.duration") .hasName("rpc.server.duration")
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> { point ->
assertThat(point) point
.hasSum(150 /* millis */) .hasSum(150 /* millis */)
.attributes() .hasAttributesSatisfying(
.containsOnly( equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"),
attributeEntry("rpc.system", "grpc"), equalTo(
attributeEntry("rpc.service", "myservice.EchoService"), SemanticAttributes.RPC_SERVICE,
attributeEntry("rpc.method", "exampleMethod"), "myservice.EchoService"),
attributeEntry("net.host.name", "example.com"), equalTo(SemanticAttributes.RPC_METHOD, "exampleMethod"),
attributeEntry("net.transport", "ip_tcp")); equalTo(
assertThat(point).exemplars().hasSize(1); SemanticAttributes.NET_HOST_NAME, "example.com"),
assertThat(point.getExemplars().get(0)) equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"))
.hasExemplarsSatisfying(
exemplar ->
exemplar
.hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00")
.hasSpanId("090a0b0c0d0e0f00"); .hasSpanId("090a0b0c0d0e0f00")))));
}));
listener.onEnd(context2, responseAttributes2, nanos(300)); listener.onEnd(context2, responseAttributes2, nanos(300));
assertThat(metricReader.collectAllMetrics()) assertThat(metricReader.collectAllMetrics())
.hasSize(1) .satisfiesExactlyInAnyOrder(
.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasName("rpc.server.duration") .hasName("rpc.server.duration")
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> { point ->
assertThat(point) point
.hasSum(150 /* millis */) .hasSum(150 /* millis */)
.attributes() .hasAttributesSatisfying(
.containsOnly( equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"),
attributeEntry("rpc.system", "grpc"), equalTo(
attributeEntry("rpc.service", "myservice.EchoService"), SemanticAttributes.RPC_SERVICE,
attributeEntry("rpc.method", "exampleMethod"), "myservice.EchoService"),
attributeEntry("net.host.ip", "127.0.0.1"), equalTo(SemanticAttributes.RPC_METHOD, "exampleMethod"),
attributeEntry("net.transport", "ip_tcp")); equalTo(SemanticAttributes.NET_HOST_IP, "127.0.0.1"),
})); equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp")))));
} }
private static long nanos(int millis) { private static long nanos(int millis) {

57
instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java
View File

@ -18,12 +18,10 @@ import io.grpc.Server;
import io.grpc.ServerBuilder; import io.grpc.ServerBuilder;
import io.grpc.Status; import io.grpc.Status;
import io.grpc.stub.StreamObserver; import io.grpc.stub.StreamObserver;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.api.trace.SpanKind;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import io.opentelemetry.instrumentation.testing.util.ThrowingRunnable; import io.opentelemetry.instrumentation.testing.util.ThrowingRunnable;
import io.opentelemetry.sdk.testing.assertj.EventDataAssert; import io.opentelemetry.sdk.testing.assertj.EventDataAssert;
import io.opentelemetry.sdk.testing.assertj.MetricAssertions;
import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; import io.opentelemetry.semconv.trace.attributes.SemanticAttributes;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@ -223,22 +221,20 @@ public abstract class AbstractGrpcStreamingTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.anySatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
Attributes.builder() equalTo(
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") SemanticAttributes.RPC_METHOD, "Conversation"),
.put(SemanticAttributes.RPC_METHOD, "Conversation") equalTo(
.put(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.grpc-1.6", "io.opentelemetry.grpc-1.6",
@ -246,26 +242,25 @@ public abstract class AbstractGrpcStreamingTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.allSatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(
Attributes.builder() SemanticAttributes.NET_PEER_NAME, "localhost"),
.put(SemanticAttributes.NET_PEER_NAME, "localhost") equalTo(
.put(
SemanticAttributes.NET_PEER_PORT, SemanticAttributes.NET_PEER_PORT,
server.getPort()) server.getPort()),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
.put(SemanticAttributes.RPC_METHOD, "Conversation") equalTo(
.put( SemanticAttributes.RPC_METHOD, "Conversation"),
equalTo(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
} }
private ManagedChannel createChannel(Server server) throws Exception { private ManagedChannel createChannel(Server server) throws Exception {

267
instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java
View File

@ -40,12 +40,10 @@ import io.grpc.reflection.v1alpha.ServerReflectionGrpc;
import io.grpc.reflection.v1alpha.ServerReflectionRequest; import io.grpc.reflection.v1alpha.ServerReflectionRequest;
import io.grpc.reflection.v1alpha.ServerReflectionResponse; import io.grpc.reflection.v1alpha.ServerReflectionResponse;
import io.grpc.stub.StreamObserver; import io.grpc.stub.StreamObserver;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.api.trace.SpanKind;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import io.opentelemetry.instrumentation.testing.util.ThrowingRunnable; import io.opentelemetry.instrumentation.testing.util.ThrowingRunnable;
import io.opentelemetry.sdk.testing.assertj.MetricAssertions;
import io.opentelemetry.sdk.trace.data.StatusData; import io.opentelemetry.sdk.trace.data.StatusData;
import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; import io.opentelemetry.semconv.trace.attributes.SemanticAttributes;
import java.util.Queue; import java.util.Queue;
@ -214,22 +212,19 @@ public abstract class AbstractGrpcTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.anySatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
Attributes.builder() equalTo(SemanticAttributes.RPC_METHOD, "SayHello"),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(
.put(SemanticAttributes.RPC_METHOD, "SayHello")
.put(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.grpc-1.6", "io.opentelemetry.grpc-1.6",
@ -237,26 +232,24 @@ public abstract class AbstractGrpcTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.allSatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(
Attributes.builder() SemanticAttributes.NET_PEER_NAME, "localhost"),
.put(SemanticAttributes.NET_PEER_NAME, "localhost") equalTo(
.put(
SemanticAttributes.NET_PEER_PORT, SemanticAttributes.NET_PEER_PORT,
server.getPort()) server.getPort()),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
.put(SemanticAttributes.RPC_METHOD, "SayHello") equalTo(SemanticAttributes.RPC_METHOD, "SayHello"),
.put( equalTo(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
} }
@Test @Test
@ -408,22 +401,19 @@ public abstract class AbstractGrpcTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.anySatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
Attributes.builder() equalTo(SemanticAttributes.RPC_METHOD, "SayHello"),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(
.put(SemanticAttributes.RPC_METHOD, "SayHello")
.put(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.grpc-1.6", "io.opentelemetry.grpc-1.6",
@ -431,26 +421,24 @@ public abstract class AbstractGrpcTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.allSatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(
Attributes.builder() SemanticAttributes.NET_PEER_NAME, "localhost"),
.put(SemanticAttributes.NET_PEER_NAME, "localhost") equalTo(
.put(
SemanticAttributes.NET_PEER_PORT, SemanticAttributes.NET_PEER_PORT,
server.getPort()) server.getPort()),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
.put(SemanticAttributes.RPC_METHOD, "SayHello") equalTo(SemanticAttributes.RPC_METHOD, "SayHello"),
.put( equalTo(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
} }
@Test @Test
@ -610,22 +598,19 @@ public abstract class AbstractGrpcTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.anySatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
Attributes.builder() equalTo(SemanticAttributes.RPC_METHOD, "SayHello"),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(
.put(SemanticAttributes.RPC_METHOD, "SayHello")
.put(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.grpc-1.6", "io.opentelemetry.grpc-1.6",
@ -633,26 +618,24 @@ public abstract class AbstractGrpcTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.allSatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(
Attributes.builder() SemanticAttributes.NET_PEER_NAME, "localhost"),
.put(SemanticAttributes.NET_PEER_NAME, "localhost") equalTo(
.put(
SemanticAttributes.NET_PEER_PORT, SemanticAttributes.NET_PEER_PORT,
server.getPort()) server.getPort()),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
.put(SemanticAttributes.RPC_METHOD, "SayHello") equalTo(SemanticAttributes.RPC_METHOD, "SayHello"),
.put( equalTo(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
} }
@ParameterizedTest @ParameterizedTest
@ -769,22 +752,19 @@ public abstract class AbstractGrpcTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.anySatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
Attributes.builder() equalTo(SemanticAttributes.RPC_METHOD, "SayHello"),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(
.put(SemanticAttributes.RPC_METHOD, "SayHello")
.put(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.grpc-1.6", "io.opentelemetry.grpc-1.6",
@ -792,26 +772,24 @@ public abstract class AbstractGrpcTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.allSatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(
Attributes.builder() SemanticAttributes.NET_PEER_NAME, "localhost"),
.put(SemanticAttributes.NET_PEER_NAME, "localhost") equalTo(
.put(
SemanticAttributes.NET_PEER_PORT, SemanticAttributes.NET_PEER_PORT,
server.getPort()) server.getPort()),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
.put(SemanticAttributes.RPC_METHOD, "SayHello") equalTo(SemanticAttributes.RPC_METHOD, "SayHello"),
.put( equalTo(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
} }
@ParameterizedTest @ParameterizedTest
@ -926,22 +904,19 @@ public abstract class AbstractGrpcTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.anySatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
Attributes.builder() equalTo(SemanticAttributes.RPC_METHOD, "SayHello"),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(
.put(SemanticAttributes.RPC_METHOD, "SayHello")
.put(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.grpc-1.6", "io.opentelemetry.grpc-1.6",
@ -949,26 +924,24 @@ public abstract class AbstractGrpcTest {
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
MetricAssertions.assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.allSatisfy( histogram.hasPointsSatisfying(
point -> point ->
MetricAssertions.assertThat(point) point.hasAttributesSatisfying(
.hasAttributes( equalTo(
Attributes.builder() SemanticAttributes.NET_PEER_NAME, "localhost"),
.put(SemanticAttributes.NET_PEER_NAME, "localhost") equalTo(
.put(
SemanticAttributes.NET_PEER_PORT, SemanticAttributes.NET_PEER_PORT,
server.getPort()) server.getPort()),
.put(SemanticAttributes.NET_TRANSPORT, "ip_tcp") equalTo(SemanticAttributes.NET_TRANSPORT, "ip_tcp"),
.put(SemanticAttributes.RPC_METHOD, "SayHello") equalTo(SemanticAttributes.RPC_METHOD, "SayHello"),
.put( equalTo(
SemanticAttributes.RPC_SERVICE, SemanticAttributes.RPC_SERVICE,
"example.Greeter") "example.Greeter"),
.put(SemanticAttributes.RPC_SYSTEM, "grpc") equalTo(SemanticAttributes.RPC_SYSTEM, "grpc"))))));
.build()))));
} }
static class ErrorProvider implements ArgumentsProvider { static class ErrorProvider implements ArgumentsProvider {

37
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/CounterTest.java
View File

@ -5,20 +5,22 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.Counter; import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import org.assertj.core.api.AbstractIterableAssert;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension; import org.junit.jupiter.api.extension.RegisterExtension;
class CounterTest { class CounterTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -29,7 +31,7 @@ class CounterTest {
} }
@Test @Test
void testCounter() { void testCounter() throws Exception {
// given // given
Counter counter = Counter counter =
Counter.builder("testCounter") Counter.builder("testCounter")
@ -52,15 +54,17 @@ class CounterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test counter") .hasDescription("This is a test counter")
.hasUnit("items") .hasUnit("items")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(3) .hasValue(3)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.clearData(); testing.clearData();
// when // when
@ -68,15 +72,8 @@ class CounterTest {
counter.increment(); counter.increment();
// then // then
Thread.sleep(100); // interval of the test metrics exporter
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME, "testCounter", AbstractIterableAssert::isEmpty);
"testCounter",
metrics ->
metrics.allSatisfy(
metric ->
assertThat(metric)
.hasDoubleSum()
.points()
.noneSatisfy(point -> assertThat(point).hasValue(4))));
} }
} }

105
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/DistributionSummaryTest.java
View File

@ -5,11 +5,12 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.DistributionSummary; import io.micrometer.core.instrument.DistributionSummary;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import org.assertj.core.api.AbstractIterableAssert; import org.assertj.core.api.AbstractIterableAssert;
@ -19,7 +20,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
class DistributionSummaryTest { class DistributionSummaryTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -30,7 +31,7 @@ class DistributionSummaryTest {
} }
@Test @Test
void testDistributionSummary() { void testDistributionSummary() throws Exception {
// given // given
DistributionSummary summary = DistributionSummary summary =
DistributionSummary.builder("testSummary") DistributionSummary.builder("testSummary")
@ -53,15 +54,16 @@ class DistributionSummaryTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test distribution summary") .hasDescription("This is a test distribution summary")
.hasUnit("things") .hasUnit("things")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasSum(42) .hasSum(42)
.hasCount(1) .hasCount(1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.clearData(); testing.clearData();
// when // when
@ -69,16 +71,9 @@ class DistributionSummaryTest {
summary.record(6); summary.record(6);
// then // then
Thread.sleep(100); // interval of the test metrics exporter
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME, "testSummary", AbstractIterableAssert::isEmpty);
"testSummary",
metrics ->
metrics.allSatisfy(
metric ->
assertThat(metric)
.hasDoubleHistogram()
.points()
.noneSatisfy(point -> assertThat(point).hasSum(54).hasCount(2))));
} }
@Test @Test
@ -107,29 +102,33 @@ class DistributionSummaryTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.anySatisfy( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point).hasValue(1).attributes().containsEntry("le", "1")) point
.anySatisfy( .hasValue(1)
.hasAttributesSatisfying(
equalTo(AttributeKey.stringKey("tag"), "value"),
equalTo(AttributeKey.stringKey("le"), "1")),
point -> point ->
assertThat(point) point
.hasValue(2) .hasValue(2)
.attributes() .hasAttributesSatisfying(
.containsEntry("le", "10")) equalTo(AttributeKey.stringKey("tag"), "value"),
.anySatisfy( equalTo(AttributeKey.stringKey("le"), "10")),
point -> point ->
assertThat(point) point
.hasValue(3) .hasValue(3)
.attributes() .hasAttributesSatisfying(
.containsEntry("le", "100")) equalTo(AttributeKey.stringKey("tag"), "value"),
.anySatisfy( equalTo(AttributeKey.stringKey("le"), "100")),
point -> point ->
assertThat(point) point
.hasValue(4) .hasValue(4)
.attributes() .hasAttributesSatisfying(
.containsEntry("le", "1000")))); equalTo(AttributeKey.stringKey("tag"), "value"),
equalTo(AttributeKey.stringKey("le"), "1000"))))));
} }
@Test @Test
@ -155,14 +154,21 @@ class DistributionSummaryTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.anySatisfy( gauge.hasPointsSatisfying(
point -> assertThat(point).attributes().containsEntry("phi", "0.5")) point ->
.anySatisfy( point.hasAttributesSatisfying(
point -> assertThat(point).attributes().containsEntry("phi", "0.95")) equalTo(AttributeKey.stringKey("tag"), "value"),
.anySatisfy( equalTo(AttributeKey.stringKey("phi"), "0.5")),
point -> assertThat(point).attributes().containsEntry("phi", "0.99")))); point ->
point.hasAttributesSatisfying(
equalTo(AttributeKey.stringKey("tag"), "value"),
equalTo(AttributeKey.stringKey("phi"), "0.95")),
point ->
point.hasAttributesSatisfying(
equalTo(AttributeKey.stringKey("tag"), "value"),
equalTo(AttributeKey.stringKey("phi"), "0.99"))))));
} }
@Test @Test
@ -189,14 +195,15 @@ class DistributionSummaryTest {
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasDescription("This is a test distribution summary") .hasDescription("This is a test distribution summary")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.anySatisfy( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(4) .hasValue(4)
.attributes() .hasAttributesSatisfying(
.containsEntry("tag", "value")))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
// when // when
Metrics.globalRegistry.remove(summary); Metrics.globalRegistry.remove(summary);

45
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/FunctionCounterTest.java
View File

@ -5,11 +5,12 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.FunctionCounter; import io.micrometer.core.instrument.FunctionCounter;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicLong;
@ -20,7 +21,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
class FunctionCounterTest { class FunctionCounterTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -53,15 +54,17 @@ class FunctionCounterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test function counter") .hasDescription("This is a test function counter")
.hasUnit("items") .hasUnit("items")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12) .hasValue(12)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
// when // when
Metrics.globalRegistry.remove(counter); Metrics.globalRegistry.remove(counter);
@ -98,20 +101,20 @@ class FunctionCounterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test function counter") .hasDescription("This is a test function counter")
.hasUnit("items") .hasUnit("items")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.anySatisfy( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12) .hasValue(12)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "1"))) equalTo(AttributeKey.stringKey("tag"), "1")),
.anySatisfy(
point -> point ->
assertThat(point) point
.hasValue(13) .hasValue(13)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "2"))))); equalTo(
AttributeKey.stringKey("tag"), "2"))))));
} }
} }

36
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/FunctionTimerSecondsTest.java
View File

@ -5,11 +5,12 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.FunctionTimer; import io.micrometer.core.instrument.FunctionTimer;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@ -20,7 +21,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
class FunctionTimerSecondsTest { class FunctionTimerSecondsTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -60,15 +61,17 @@ class FunctionTimerSecondsTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test function timer") .hasDescription("This is a test function timer")
.hasUnit("1") .hasUnit("1")
.hasLongSum() .hasLongSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(1) .hasValue(1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testFunctionTimerSeconds.sum", "testFunctionTimerSeconds.sum",
@ -78,14 +81,15 @@ class FunctionTimerSecondsTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test function timer") .hasDescription("This is a test function timer")
.hasUnit("s") .hasUnit("s")
.hasDoubleSum() .hasDoubleSumSatisfying(
.points() sum ->
.satisfiesExactly( sum.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(42) .hasValue(42)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
// when // when
Metrics.globalRegistry.remove(functionTimer); Metrics.globalRegistry.remove(functionTimer);

61
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/FunctionTimerTest.java
View File

@ -5,11 +5,12 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.FunctionTimer; import io.micrometer.core.instrument.FunctionTimer;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@ -20,7 +21,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
class FunctionTimerTest { class FunctionTimerTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -62,15 +63,17 @@ class FunctionTimerTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test function timer") .hasDescription("This is a test function timer")
.hasUnit("1") .hasUnit("1")
.hasLongSum() .hasLongSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(1) .hasValue(1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testFunctionTimer.sum", "testFunctionTimer.sum",
@ -80,14 +83,15 @@ class FunctionTimerTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test function timer") .hasDescription("This is a test function timer")
.hasUnit("ms") .hasUnit("ms")
.hasDoubleSum() .hasDoubleSumSatisfying(
.points() sum ->
.satisfiesExactly( sum.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(42_000) .hasValue(42_000)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
// when // when
Metrics.globalRegistry.remove(functionTimer); Metrics.globalRegistry.remove(functionTimer);
@ -125,10 +129,8 @@ class FunctionTimerTest {
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleSum() .hasDoubleSumSatisfying(
.points() sum -> sum.hasPointsSatisfying(point -> point.hasValue(1.234)))));
.satisfiesExactly(
point -> assertThat(point).hasValue(1.234).attributes())));
} }
@Test @Test
@ -165,19 +167,18 @@ class FunctionTimerTest {
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleSum() .hasDoubleSumSatisfying(
.points() sum ->
.anySatisfy( sum.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12_000) .hasValue(12_000)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "1"))) equalTo(AttributeKey.stringKey("tag"), "1")),
.anySatisfy(
point -> point ->
assertThat(point) point
.hasValue(42_000) .hasValue(42_000)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "2"))))); equalTo(AttributeKey.stringKey("tag"), "2"))))));
} }
} }

44
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/GaugeTest.java
View File

@ -5,11 +5,12 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.Gauge; import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.test.utils.GcUtils; import io.opentelemetry.instrumentation.test.utils.GcUtils;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
@ -22,7 +23,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
class GaugeTest { class GaugeTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -52,14 +53,15 @@ class GaugeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test gauge") .hasDescription("This is a test gauge")
.hasUnit("items") .hasUnit("items")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() g ->
.satisfiesExactly( g.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(42) .hasValue(42)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
// when // when
Metrics.globalRegistry.remove(gauge); Metrics.globalRegistry.remove(gauge);
@ -96,20 +98,19 @@ class GaugeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test gauge") .hasDescription("This is a test gauge")
.hasUnit("items") .hasUnit("items")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.anySatisfy( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12) .hasValue(12)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "1"))) equalTo(AttributeKey.stringKey("tag"), "1")),
.anySatisfy(
point -> point ->
assertThat(point) point
.hasValue(42) .hasValue(42)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "2"))))); equalTo(AttributeKey.stringKey("tag"), "2"))))));
} }
@Test @Test
@ -128,9 +129,8 @@ class GaugeTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge -> gauge.hasPointsSatisfying(point -> point.hasValue(42)))));
.satisfiesExactly(point -> assertThat(point).hasValue(42))));
// when // when
WeakReference<AtomicLong> numWeakRef = new WeakReference<>(num); WeakReference<AtomicLong> numWeakRef = new WeakReference<>(num);

68
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/LongTaskTimerSecondsTest.java
View File

@ -5,11 +5,12 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.LongTaskTimer; import io.micrometer.core.instrument.LongTaskTimer;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@ -20,7 +21,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
class LongTaskTimerSecondsTest { class LongTaskTimerSecondsTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -52,15 +53,17 @@ class LongTaskTimerSecondsTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test long task timer") .hasDescription("This is a test long task timer")
.hasUnit("tasks") .hasUnit("tasks")
.hasLongSum() .hasLongSumSatisfying(
.isNotMonotonic() sum ->
.points() sum.isNotMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(1) .hasValue(1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testLongTaskTimerSeconds.duration", "testLongTaskTimerSeconds.duration",
@ -70,17 +73,18 @@ class LongTaskTimerSecondsTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test long task timer") .hasDescription("This is a test long task timer")
.hasUnit("s") .hasUnit("s")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isNotMonotonic() sum ->
.points() sum.isNotMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> { point -> {
assertThat(point) point.hasAttributesSatisfying(
.attributes() equalTo(AttributeKey.stringKey("tag"), "value"));
.containsOnly(attributeEntry("tag", "value"));
// any value >0 - duration of currently running tasks // any value >0 - duration of currently running tasks
assertThat(point.getValue()).isPositive(); assertThat(metric.getDoubleSumData().getPoints())
}))); .satisfiesExactly(
p -> assertThat(p.getValue()).isPositive());
}))));
// when // when
TimeUnit.MILLISECONDS.sleep(100); TimeUnit.MILLISECONDS.sleep(100);
@ -94,14 +98,15 @@ class LongTaskTimerSecondsTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasLongSum() .hasLongSumSatisfying(
.points() sum ->
.satisfiesExactly( sum.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(0) .hasValue(0)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testLongTaskTimerSeconds.duration", "testLongTaskTimerSeconds.duration",
@ -109,14 +114,15 @@ class LongTaskTimerSecondsTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasDoubleSum() .hasDoubleSumSatisfying(
.points() sum ->
.satisfiesExactly( sum.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(0) .hasValue(0)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
// when timer is removed from the registry // when timer is removed from the registry
Metrics.globalRegistry.remove(timer); Metrics.globalRegistry.remove(timer);

68
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/LongTaskTimerTest.java
View File

@ -5,11 +5,12 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.LongTaskTimer; import io.micrometer.core.instrument.LongTaskTimer;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@ -20,7 +21,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
class LongTaskTimerTest { class LongTaskTimerTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -52,15 +53,17 @@ class LongTaskTimerTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test long task timer") .hasDescription("This is a test long task timer")
.hasUnit("tasks") .hasUnit("tasks")
.hasLongSum() .hasLongSumSatisfying(
.isNotMonotonic() sum ->
.points() sum.isNotMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(1) .hasValue(1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testLongTaskTimer.duration", "testLongTaskTimer.duration",
@ -70,17 +73,18 @@ class LongTaskTimerTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test long task timer") .hasDescription("This is a test long task timer")
.hasUnit("ms") .hasUnit("ms")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isNotMonotonic() sum ->
.points() sum.isNotMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> { point -> {
assertThat(point) point.hasAttributesSatisfying(
.attributes() equalTo(AttributeKey.stringKey("tag"), "value"));
.containsOnly(attributeEntry("tag", "value"));
// any value >0 - duration of currently running tasks // any value >0 - duration of currently running tasks
assertThat(point.getValue()).isPositive(); assertThat(metric.getDoubleSumData().getPoints())
}))); .satisfiesExactly(
p -> assertThat(p.getValue()).isPositive());
}))));
// when // when
TimeUnit.MILLISECONDS.sleep(100); TimeUnit.MILLISECONDS.sleep(100);
@ -94,14 +98,15 @@ class LongTaskTimerTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasLongSum() .hasLongSumSatisfying(
.points() sum ->
.satisfiesExactly( sum.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(0) .hasValue(0)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testLongTaskTimer.duration", "testLongTaskTimer.duration",
@ -109,14 +114,15 @@ class LongTaskTimerTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasDoubleSum() .hasDoubleSumSatisfying(
.points() sum ->
.satisfiesExactly( sum.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(0) .hasValue(0)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
// when timer is removed from the registry // when timer is removed from the registry
Metrics.globalRegistry.remove(timer); Metrics.globalRegistry.remove(timer);

123
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/MeterTest.java
View File

@ -5,13 +5,14 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.Measurement; import io.micrometer.core.instrument.Measurement;
import io.micrometer.core.instrument.Meter; import io.micrometer.core.instrument.Meter;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.micrometer.core.instrument.Statistic; import io.micrometer.core.instrument.Statistic;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.util.Arrays; import java.util.Arrays;
@ -24,7 +25,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
class MeterTest { class MeterTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -68,15 +69,17 @@ class MeterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test meter") .hasDescription("This is a test meter")
.hasUnit("things") .hasUnit("things")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12345) .hasValue(12345)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testMeter.total_time", "testMeter.total_time",
@ -86,15 +89,17 @@ class MeterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test meter") .hasDescription("This is a test meter")
.hasUnit("things") .hasUnit("things")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12345) .hasValue(12345)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testMeter.count", "testMeter.count",
@ -104,15 +109,17 @@ class MeterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test meter") .hasDescription("This is a test meter")
.hasUnit("things") .hasUnit("things")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12345) .hasValue(12345)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testMeter.active", "testMeter.active",
@ -122,15 +129,17 @@ class MeterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test meter") .hasDescription("This is a test meter")
.hasUnit("things") .hasUnit("things")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isNotMonotonic() sum ->
.points() sum.isNotMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12345) .hasValue(12345)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testMeter.duration", "testMeter.duration",
@ -140,14 +149,15 @@ class MeterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test meter") .hasDescription("This is a test meter")
.hasUnit("things") .hasUnit("things")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.satisfiesExactly( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12345) .hasValue(12345)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testMeter.max", "testMeter.max",
@ -157,14 +167,15 @@ class MeterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test meter") .hasDescription("This is a test meter")
.hasUnit("things") .hasUnit("things")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.satisfiesExactly( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12345) .hasValue(12345)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testMeter.value", "testMeter.value",
@ -174,14 +185,15 @@ class MeterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test meter") .hasDescription("This is a test meter")
.hasUnit("things") .hasUnit("things")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.satisfiesExactly( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12345) .hasValue(12345)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testMeter.unknown", "testMeter.unknown",
@ -191,14 +203,15 @@ class MeterTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test meter") .hasDescription("This is a test meter")
.hasUnit("things") .hasUnit("things")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.satisfiesExactly( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12345) .hasValue(12345)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
// when // when
Metrics.globalRegistry.remove(meter); Metrics.globalRegistry.remove(meter);

178
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/PrometheusModeTest.java
View File

@ -5,8 +5,8 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.Counter; import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.DistributionSummary; import io.micrometer.core.instrument.DistributionSummary;
@ -15,6 +15,7 @@ import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.LongTaskTimer; import io.micrometer.core.instrument.LongTaskTimer;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.micrometer.core.instrument.Timer; import io.micrometer.core.instrument.Timer;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@ -25,7 +26,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
@SuppressWarnings("PreferJavaTimeOverload") @SuppressWarnings("PreferJavaTimeOverload")
class PrometheusModeTest { class PrometheusModeTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -60,15 +61,17 @@ class PrometheusModeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test counter") .hasDescription("This is a test counter")
.hasUnit("items") .hasUnit("items")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12) .hasValue(12)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
} }
@Test @Test
@ -95,15 +98,16 @@ class PrometheusModeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test summary") .hasDescription("This is a test summary")
.hasUnit("items") .hasUnit("items")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasSum(54) .hasSum(54)
.hasCount(2) .hasCount(2)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testPrometheusSummary.items.max", "testPrometheusSummary.items.max",
@ -113,14 +117,15 @@ class PrometheusModeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test summary") .hasDescription("This is a test summary")
.hasUnit("items") .hasUnit("items")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.satisfiesExactly( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(42) .hasValue(42)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
} }
@Test @Test
@ -149,15 +154,17 @@ class PrometheusModeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test function timer") .hasDescription("This is a test function timer")
.hasUnit("1") .hasUnit("1")
.hasLongSum() .hasLongSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(1) .hasValue(1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testPrometheusFunctionTimer.seconds.sum", "testPrometheusFunctionTimer.seconds.sum",
@ -167,14 +174,15 @@ class PrometheusModeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test function timer") .hasDescription("This is a test function timer")
.hasUnit("s") .hasUnit("s")
.hasDoubleSum() .hasDoubleSumSatisfying(
.points() sum ->
.satisfiesExactly( sum.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(42) .hasValue(42)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
} }
@Test @Test
@ -196,14 +204,15 @@ class PrometheusModeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test gauge") .hasDescription("This is a test gauge")
.hasUnit("items") .hasUnit("items")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.satisfiesExactly( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(42) .hasValue(42)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
} }
@Test @Test
@ -228,15 +237,17 @@ class PrometheusModeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test long task timer") .hasDescription("This is a test long task timer")
.hasUnit("tasks") .hasUnit("tasks")
.hasLongSum() .hasLongSumSatisfying(
.isNotMonotonic() sum ->
.points() sum.isNotMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(1) .hasValue(1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testPrometheusLongTaskTimer.seconds.duration", "testPrometheusLongTaskTimer.seconds.duration",
@ -246,17 +257,18 @@ class PrometheusModeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test long task timer") .hasDescription("This is a test long task timer")
.hasUnit("s") .hasUnit("s")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isNotMonotonic() sum ->
.points() sum.isNotMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> { point -> {
assertThat(point) point.hasAttributesSatisfying(
.attributes() equalTo(AttributeKey.stringKey("tag"), "value"));
.containsOnly(attributeEntry("tag", "value"));
// any value >0 - duration of currently running tasks // any value >0 - duration of currently running tasks
assertThat(point.getValue()).isPositive(); assertThat(metric.getDoubleSumData().getPoints())
}))); .satisfiesExactly(
p -> assertThat(p.getValue()).isPositive());
}))));
// when // when
TimeUnit.MILLISECONDS.sleep(100); TimeUnit.MILLISECONDS.sleep(100);
@ -270,14 +282,15 @@ class PrometheusModeTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasLongSum() .hasLongSumSatisfying(
.points() sum ->
.satisfiesExactly( sum.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(0) .hasValue(0)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testPrometheusLongTaskTimer.seconds.duration", "testPrometheusLongTaskTimer.seconds.duration",
@ -285,14 +298,15 @@ class PrometheusModeTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasDoubleSum() .hasDoubleSumSatisfying(
.points() sum ->
.satisfiesExactly( sum.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(0) .hasValue(0)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
} }
@Test @Test
@ -319,15 +333,16 @@ class PrometheusModeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test timer") .hasDescription("This is a test timer")
.hasUnit("s") .hasUnit("s")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasSum(16.789) .hasSum(16.789)
.hasCount(3) .hasCount(3)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testPrometheusTimer.seconds.max", "testPrometheusTimer.seconds.max",
@ -337,13 +352,14 @@ class PrometheusModeTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test timer") .hasDescription("This is a test timer")
.hasUnit("s") .hasUnit("s")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.satisfiesExactly( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(10.789) .hasValue(10.789)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
} }
} }

43
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/TimerSecondsTest.java
View File

@ -5,11 +5,12 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.micrometer.core.instrument.Timer; import io.micrometer.core.instrument.Timer;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@ -21,7 +22,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
@SuppressWarnings("PreferJavaTimeOverload") @SuppressWarnings("PreferJavaTimeOverload")
class TimerSecondsTest { class TimerSecondsTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -55,15 +56,16 @@ class TimerSecondsTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test timer") .hasDescription("This is a test timer")
.hasUnit("s") .hasUnit("s")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasSum(23.345) .hasSum(23.345)
.hasCount(3) .hasCount(3)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME,
"testTimerSeconds.max", "testTimerSeconds.max",
@ -73,14 +75,15 @@ class TimerSecondsTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test timer") .hasDescription("This is a test timer")
.hasUnit("s") .hasUnit("s")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.anySatisfy( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12.345) .hasValue(12.345)
.attributes() .hasAttributesSatisfying(
.containsEntry("tag", "value")))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.clearData(); testing.clearData();
// when // when
@ -92,15 +95,7 @@ class TimerSecondsTest {
// then // then
Thread.sleep(100); // interval of the test metrics exporter Thread.sleep(100); // interval of the test metrics exporter
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME, "testTimerSeconds", AbstractIterableAssert::isEmpty);
"testTimerSeconds",
metrics ->
metrics.allSatisfy(
metric ->
assertThat(metric)
.hasDoubleHistogram()
.points()
.noneSatisfy(point -> assertThat(point).hasSum(35.345).hasCount(4))));
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, "testTimerMax.max", AbstractIterableAssert::isEmpty); INSTRUMENTATION_NAME, "testTimerMax.max", AbstractIterableAssert::isEmpty);
} }

115
instrumentation/micrometer/micrometer-1.5/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/micrometer/v1_5/TimerTest.java
View File

@ -5,11 +5,12 @@
package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5; package io.opentelemetry.javaagent.instrumentation.micrometer.v1_5;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.Metrics; import io.micrometer.core.instrument.Metrics;
import io.micrometer.core.instrument.Timer; import io.micrometer.core.instrument.Timer;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.time.Duration; import java.time.Duration;
@ -22,7 +23,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
@SuppressWarnings("PreferJavaTimeOverload") @SuppressWarnings("PreferJavaTimeOverload")
class TimerTest { class TimerTest {
static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometershim"; static final String INSTRUMENTATION_NAME = "io.opentelemetry.micrometer1shim";
@RegisterExtension @RegisterExtension
static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
@ -33,7 +34,7 @@ class TimerTest {
} }
@Test @Test
void testTimer() { void testTimer() throws Exception {
// given // given
Timer timer = Timer timer =
Timer.builder("testTimer") Timer.builder("testTimer")
@ -54,15 +55,16 @@ class TimerTest {
assertThat(metric) assertThat(metric)
.hasDescription("This is a test timer") .hasDescription("This is a test timer")
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasSum(42_000) .hasSum(42_000)
.hasCount(1) .hasCount(1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
testing.clearData(); testing.clearData();
// when // when
@ -70,16 +72,9 @@ class TimerTest {
timer.record(12, TimeUnit.SECONDS); timer.record(12, TimeUnit.SECONDS);
// then // then
Thread.sleep(100); // interval of the test metrics exporter
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
INSTRUMENTATION_NAME, INSTRUMENTATION_NAME, "testTimerMax", AbstractIterableAssert::isEmpty);
"testTimer",
metrics ->
metrics.allSatisfy(
metric ->
assertThat(metric)
.hasDoubleHistogram()
.points()
.noneSatisfy(point -> assertThat(point).hasSum(54_000).hasCount(2))));
} }
@Test @Test
@ -99,10 +94,10 @@ class TimerTest {
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.satisfiesExactly( histogram.hasPointsSatisfying(
point -> assertThat(point).hasSum(1.234).hasCount(1).attributes()))); point -> point.hasSum(1.234).hasCount(1)))));
} }
@Test @Test
@ -134,32 +129,34 @@ class TimerTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.anySatisfy( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(1) .hasValue(1)
.attributes() .hasAttributesSatisfying(
.containsEntry("le", "1000")) equalTo(AttributeKey.stringKey("tag"), "value"),
.anySatisfy( equalTo(AttributeKey.stringKey("le"), "1000")),
point -> point ->
assertThat(point) point
.hasValue(2) .hasValue(2)
.attributes() .hasAttributesSatisfying(
.containsEntry("le", "10000")) equalTo(AttributeKey.stringKey("tag"), "value"),
.anySatisfy( equalTo(AttributeKey.stringKey("le"), "10000")),
point -> point ->
assertThat(point) point
.hasValue(3) .hasValue(3)
.attributes() .hasAttributesSatisfying(
.containsEntry("le", "100000")) equalTo(AttributeKey.stringKey("tag"), "value"),
.anySatisfy( equalTo(AttributeKey.stringKey("le"), "100000")),
point -> point ->
assertThat(point) point
.hasValue(4) .hasValue(4)
.attributes() .hasAttributesSatisfying(
.containsEntry("le", "1000000")))); equalTo(AttributeKey.stringKey("tag"), "value"),
equalTo(
AttributeKey.stringKey("le"), "1000000"))))));
} }
@Test @Test
@ -184,14 +181,21 @@ class TimerTest {
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.anySatisfy( gauge.hasPointsSatisfying(
point -> assertThat(point).attributes().containsEntry("phi", "0.5")) point ->
.anySatisfy( point.hasAttributesSatisfying(
point -> assertThat(point).attributes().containsEntry("phi", "0.95")) equalTo(AttributeKey.stringKey("tag"), "value"),
.anySatisfy( equalTo(AttributeKey.stringKey("phi"), "0.5")),
point -> assertThat(point).attributes().containsEntry("phi", "0.99")))); point ->
point.hasAttributesSatisfying(
equalTo(AttributeKey.stringKey("tag"), "value"),
equalTo(AttributeKey.stringKey("phi"), "0.95")),
point ->
point.hasAttributesSatisfying(
equalTo(AttributeKey.stringKey("tag"), "value"),
equalTo(AttributeKey.stringKey("phi"), "0.99"))))));
} }
@Test @Test
@ -217,14 +221,15 @@ class TimerTest {
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasDescription("This is a test timer") .hasDescription("This is a test timer")
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.anySatisfy( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(4_000) .hasValue(4_000)
.attributes() .hasAttributesSatisfying(
.containsEntry("tag", "value")))); equalTo(
AttributeKey.stringKey("tag"), "value"))))));
// when // when
Metrics.globalRegistry.remove(timer); Metrics.globalRegistry.remove(timer);

123
instrumentation/opentelemetry-api/opentelemetry-api-1.10/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/opentelemetryapi/v1_10/metrics/MeterTest.java
View File

@ -5,8 +5,8 @@
package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics; package io.opentelemetry.javaagent.instrumentation.opentelemetryapi.v1_10.metrics;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.common.Attributes;
@ -19,7 +19,6 @@ import io.opentelemetry.api.metrics.LongUpDownCounter;
import io.opentelemetry.api.metrics.Meter; import io.opentelemetry.api.metrics.Meter;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.sdk.common.InstrumentationScopeInfo; import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo; import org.junit.jupiter.api.TestInfo;
@ -65,15 +64,15 @@ class MeterTest {
.hasInstrumentationScope( .hasInstrumentationScope(
InstrumentationScopeInfo.create( InstrumentationScopeInfo.create(
instrumentationName, "1.2.3", /* schemaUrl= */ null)) instrumentationName, "1.2.3", /* schemaUrl= */ null))
.hasLongSum() .hasLongSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(11) .hasValue(11)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("q", "r"))))); equalTo(AttributeKey.stringKey("q"), "r"))))));
} }
@Test @Test
@ -96,15 +95,15 @@ class MeterTest {
.hasInstrumentationScope( .hasInstrumentationScope(
InstrumentationScopeInfo.create( InstrumentationScopeInfo.create(
instrumentationName, "1.2.3", /* schemaUrl= */ null)) instrumentationName, "1.2.3", /* schemaUrl= */ null))
.hasLongSum() .hasLongSumSatisfying(
.isNotMonotonic() sum ->
.points() sum.isNotMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(11) .hasValue(11)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("q", "r"))))); equalTo(AttributeKey.stringKey("q"), "r"))))));
} }
@Test @Test
@ -127,15 +126,15 @@ class MeterTest {
.hasInstrumentationScope( .hasInstrumentationScope(
InstrumentationScopeInfo.create( InstrumentationScopeInfo.create(
instrumentationName, "1.2.3", /* schemaUrl= */ null)) instrumentationName, "1.2.3", /* schemaUrl= */ null))
.hasDoubleSum() .hasDoubleSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12.1) .hasValue(12.1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("q", "r"))))); equalTo(AttributeKey.stringKey("q"), "r"))))));
} }
@Test @Test
@ -158,15 +157,15 @@ class MeterTest {
.hasInstrumentationScope( .hasInstrumentationScope(
InstrumentationScopeInfo.create( InstrumentationScopeInfo.create(
instrumentationName, "1.2.3", /* schemaUrl= */ null)) instrumentationName, "1.2.3", /* schemaUrl= */ null))
.hasDoubleSum() .hasDoubleSumSatisfying(
.isNotMonotonic() sum ->
.points() sum.isNotMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(12.1) .hasValue(12.1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("q", "r"))))); equalTo(AttributeKey.stringKey("q"), "r"))))));
} }
@Test @Test
@ -182,22 +181,21 @@ class MeterTest {
"test", "test",
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> { metric ->
assertThat(metric) assertThat(metric)
.hasDescription("d") .hasDescription("d")
.hasUnit("u") .hasUnit("u")
.hasInstrumentationScope( .hasInstrumentationScope(
InstrumentationScopeInfo.create( InstrumentationScopeInfo.create(
instrumentationName, "1.2.3", /* schemaUrl= */ null)) instrumentationName, "1.2.3", /* schemaUrl= */ null))
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.allSatisfy( histogram.hasPointsSatisfying(
point -> { point ->
Assertions.assertThat(point.getSum()).isEqualTo(11.0); point
Assertions.assertThat(point.getAttributes()) .hasSum(11.0)
.isEqualTo(Attributes.of(AttributeKey.stringKey("q"), "r")); .hasAttributesSatisfying(
}); equalTo(AttributeKey.stringKey("q"), "r"))))));
}));
} }
@Test @Test
@ -213,22 +211,21 @@ class MeterTest {
"test", "test",
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> { metric ->
assertThat(metric) assertThat(metric)
.hasDescription("d") .hasDescription("d")
.hasUnit("u") .hasUnit("u")
.hasInstrumentationScope( .hasInstrumentationScope(
InstrumentationScopeInfo.create( InstrumentationScopeInfo.create(
instrumentationName, "1.2.3", /* schemaUrl= */ null)) instrumentationName, "1.2.3", /* schemaUrl= */ null))
.hasDoubleHistogram() .hasHistogramSatisfying(
.points() histogram ->
.allSatisfy( histogram.hasPointsSatisfying(
point -> { point ->
Assertions.assertThat(point.getSum()).isEqualTo(12.1); point
Assertions.assertThat(point.getAttributes()) .hasSum(12.1)
.isEqualTo(Attributes.of(AttributeKey.stringKey("q"), "r")); .hasAttributesSatisfying(
}); equalTo(AttributeKey.stringKey("q"), "r"))))));
}));
} }
@Test @Test
@ -253,14 +250,14 @@ class MeterTest {
.hasInstrumentationScope( .hasInstrumentationScope(
InstrumentationScopeInfo.create( InstrumentationScopeInfo.create(
instrumentationName, "1.2.3", /* schemaUrl= */ null)) instrumentationName, "1.2.3", /* schemaUrl= */ null))
.hasLongGauge() .hasLongGaugeSatisfying(
.points() gauge ->
.satisfiesExactly( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(123) .hasValue(123)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("q", "r"))))); equalTo(AttributeKey.stringKey("q"), "r"))))));
} }
@Test @Test
@ -284,13 +281,13 @@ class MeterTest {
.hasInstrumentationScope( .hasInstrumentationScope(
InstrumentationScopeInfo.create( InstrumentationScopeInfo.create(
instrumentationName, "1.2.3", /* schemaUrl= */ null)) instrumentationName, "1.2.3", /* schemaUrl= */ null))
.hasDoubleGauge() .hasDoubleGaugeSatisfying(
.points() gauge ->
.satisfiesExactly( gauge.hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(1.23) .hasValue(1.23)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("q", "r"))))); equalTo(AttributeKey.stringKey("q"), "r"))))));
} }
} }

20
instrumentation/oshi/testing/src/main/java/io/opentelemetry/instrumentation/oshi/AbstractProcessMetricsTest.java
View File

@ -5,7 +5,7 @@
package io.opentelemetry.instrumentation.oshi; package io.opentelemetry.instrumentation.oshi;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
@ -31,9 +31,12 @@ public abstract class AbstractProcessMetricsTest {
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasUnit("By") .hasUnit("By")
.hasLongSum() // TODO(anuraaga): Provide fuzzy value matching
.points() .hasLongSumSatisfying(
.anySatisfy(point -> assertThat(point.getValue()).isPositive()))); sum ->
assertThat(metric.getLongSumData().getPoints())
.anySatisfy(
point -> assertThat(point.getValue()).isPositive()))));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.oshi", "io.opentelemetry.oshi",
@ -43,8 +46,11 @@ public abstract class AbstractProcessMetricsTest {
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasUnit("ms") .hasUnit("ms")
.hasLongGauge() // TODO(anuraaga): Provide fuzzy value matching
.points() .hasLongGaugeSatisfying(
.anySatisfy(point -> assertThat(point.getValue()).isPositive()))); gauge ->
assertThat(metric.getLongGaugeData().getPoints())
.anySatisfy(
point -> assertThat(point.getValue()).isPositive()))));
} }
} }

38
instrumentation/oshi/testing/src/main/java/io/opentelemetry/instrumentation/oshi/AbstractSystemMetricsTest.java
View File

@ -5,10 +5,9 @@
package io.opentelemetry.instrumentation.oshi; package io.opentelemetry.instrumentation.oshi;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
public abstract class AbstractSystemMetricsTest { public abstract class AbstractSystemMetricsTest {
@ -32,10 +31,12 @@ public abstract class AbstractSystemMetricsTest {
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasUnit("By") .hasUnit("By")
.hasLongSum() // TODO(anuraaga): Provide fuzzy value matching
.points() .hasLongSumSatisfying(
sum ->
assertThat(metric.getLongSumData().getPoints())
.anySatisfy( .anySatisfy(
point -> Assertions.assertThat(point.getValue()).isPositive()))); point -> assertThat(point.getValue()).isPositive()))));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.oshi", "io.opentelemetry.oshi",
@ -45,38 +46,49 @@ public abstract class AbstractSystemMetricsTest {
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasUnit("1") .hasUnit("1")
.hasDoubleGauge() // TODO(anuraaga): Provide fuzzy value matching
.points() .hasDoubleGaugeSatisfying(
gauge ->
assertThat(metric.getDoubleGaugeData().getPoints())
.anySatisfy( .anySatisfy(
point -> Assertions.assertThat(point.getValue()).isPositive()))); point -> assertThat(point.getValue()).isPositive()))));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.oshi", "io.opentelemetry.oshi",
"system.network.io", "system.network.io",
metrics -> metrics.anySatisfy(metric -> assertThat(metric).hasUnit("By").hasLongSum())); metrics ->
metrics.anySatisfy(
metric -> assertThat(metric).hasUnit("By").hasLongSumSatisfying(sum -> {})));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.oshi", "io.opentelemetry.oshi",
"system.network.packets", "system.network.packets",
metrics -> metrics ->
metrics.anySatisfy(metric -> assertThat(metric).hasUnit("packets").hasLongSum())); metrics.anySatisfy(
metric ->
assertThat(metric).hasUnit("packets").hasLongSumSatisfying(sum -> {})));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.oshi", "io.opentelemetry.oshi",
"system.network.errors", "system.network.errors",
metrics -> metrics ->
metrics.anySatisfy(metric -> assertThat(metric).hasUnit("errors").hasLongSum())); metrics.anySatisfy(
metric ->
assertThat(metric).hasUnit("errors").hasLongSumSatisfying(sum -> {})));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.oshi", "io.opentelemetry.oshi",
"system.disk.io", "system.disk.io",
metrics -> metrics.anySatisfy(metric -> assertThat(metric).hasUnit("By").hasLongSum())); metrics ->
metrics.anySatisfy(
metric -> assertThat(metric).hasUnit("By").hasLongSumSatisfying(sum -> {})));
testing() testing()
.waitAndAssertMetrics( .waitAndAssertMetrics(
"io.opentelemetry.oshi", "io.opentelemetry.oshi",
"system.disk.operations", "system.disk.operations",
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> assertThat(metric).hasUnit("operations").hasLongSum())); metric ->
assertThat(metric).hasUnit("operations").hasLongSumSatisfying(sum -> {})));
} }
} }

23
instrumentation/spring/spring-boot-actuator-autoconfigure-2.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/spring/actuator/ActuatorTest.java
View File

@ -5,11 +5,12 @@
package io.opentelemetry.javaagent.instrumentation.spring.actuator; package io.opentelemetry.javaagent.instrumentation.spring.actuator;
import static io.opentelemetry.sdk.testing.assertj.MetricAssertions.assertThat; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.attributeEntry; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
import io.micrometer.core.instrument.MeterRegistry; import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.composite.CompositeMeterRegistry; import io.micrometer.core.instrument.composite.CompositeMeterRegistry;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.instrumentation.testing.internal.AutoCleanupExtension; import io.opentelemetry.instrumentation.testing.internal.AutoCleanupExtension;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
@ -36,22 +37,24 @@ class ActuatorTest {
testBean.inc(); testBean.inc();
testing.waitAndAssertMetrics( testing.waitAndAssertMetrics(
"io.opentelemetry.micrometershim", "io.opentelemetry.micrometer1shim",
"test-counter", "test-counter",
metrics -> metrics ->
metrics.anySatisfy( metrics.anySatisfy(
metric -> metric ->
assertThat(metric) assertThat(metric)
.hasUnit("thingies") .hasUnit("thingies")
.hasDoubleSum() .hasDoubleSumSatisfying(
.isMonotonic() sum ->
.points() sum.isMonotonic()
.satisfiesExactly( .hasPointsSatisfying(
point -> point ->
assertThat(point) point
.hasValue(1) .hasValue(1)
.attributes() .hasAttributesSatisfying(
.containsOnly(attributeEntry("tag", "value"))))); equalTo(
AttributeKey.stringKey("tag"),
"value"))))));
MeterRegistry meterRegistry = context.getBean(MeterRegistry.class); MeterRegistry meterRegistry = context.getBean(MeterRegistry.class);
assertThat(meterRegistry).isNotNull().isInstanceOf(CompositeMeterRegistry.class); assertThat(meterRegistry).isNotNull().isInstanceOf(CompositeMeterRegistry.class);

1
testing-common/build.gradle.kts
View File

@ -38,7 +38,6 @@ dependencies {
api("io.opentelemetry:opentelemetry-sdk") api("io.opentelemetry:opentelemetry-sdk")
api("io.opentelemetry:opentelemetry-sdk-testing") api("io.opentelemetry:opentelemetry-sdk-testing")
api("io.opentelemetry:opentelemetry-sdk-metrics") api("io.opentelemetry:opentelemetry-sdk-metrics")
api("io.opentelemetry:opentelemetry-sdk-metrics-testing")
api("io.opentelemetry:opentelemetry-sdk-logs") api("io.opentelemetry:opentelemetry-sdk-logs")
api(project(":instrumentation-api")) api(project(":instrumentation-api"))

2
testing/agent-exporter/src/main/java/io/opentelemetry/javaagent/testing/exporter/AgentTestingExporterFactory.java
View File

@ -28,7 +28,7 @@ public class AgentTestingExporterFactory {
public static void reset() { public static void reset() {
// Flush meter provider to remove any lingering measurements // Flush meter provider to remove any lingering measurements
AgentTestingCustomizer.metricReader.flush().join(10, TimeUnit.SECONDS); AgentTestingCustomizer.metricReader.forceFlush().join(10, TimeUnit.SECONDS);
spanExporter.reset(); spanExporter.reset();
metricExporter.reset(); metricExporter.reset();
logExporter.reset(); logExporter.reset();