From 4516222d5cce1a26ad211ff63963d285206d7638 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Tue, 16 Jul 2024 17:42:21 +0800 Subject: [PATCH 01/24] grpc support request/response size --- .../semconv/rpc/RpcAttributesGetter.java | 16 ++++++ .../semconv/rpc/RpcClientMetrics.java | 39 ++++++++++++- .../rpc/RpcCommonAttributesExtractor.java | 18 +++++- .../semconv/rpc/RpcMessageBodySizeUtil.java | 47 +++++++++++++++ .../semconv/rpc/RpcMetricsAdvice.java | 39 +++++++++++++ .../semconv/rpc/RpcServerMetrics.java | 39 ++++++++++++- .../semconv/rpc/RpcClientMetricsTest.java | 57 +++++++++++++++++++ .../semconv/rpc/RpcServerMetricsTest.java | 55 ++++++++++++++++++ .../grpc-1.6/library/build.gradle.kts | 1 + .../grpc/v1_6/BodySizeUtil.java | 22 +++++++ .../grpc/v1_6/GrpcRequest.java | 37 ++++++++++++ .../grpc/v1_6/GrpcRpcAttributesGetter.java | 21 +++++++ .../grpc/v1_6/TracingClientInterceptor.java | 2 + .../grpc/v1_6/TracingServerInterceptor.java | 2 + 14 files changed, 388 insertions(+), 7 deletions(-) create mode 100644 instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java create mode 100644 instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/BodySizeUtil.java diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcAttributesGetter.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcAttributesGetter.java index 2e7d0a6e539d..a15db2015418 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcAttributesGetter.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcAttributesGetter.java @@ -24,4 +24,20 @@ public interface RpcAttributesGetter { @Nullable String getMethod(REQUEST request); + + default int getClientRequestSize(REQUEST request) { + return 0; + } + + default int getClientResponseSize(REQUEST request) { + return 0; + } + + default int getServerRequestSize(REQUEST request) { + return 0; + } + + default int getServerResponseSize(REQUEST request) { + return 0; + } } diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java index e0e379410f4f..d6f885b384f9 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java @@ -11,6 +11,8 @@ import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.metrics.DoubleHistogram; import io.opentelemetry.api.metrics.DoubleHistogramBuilder; +import io.opentelemetry.api.metrics.LongHistogram; +import io.opentelemetry.api.metrics.LongHistogramBuilder; import io.opentelemetry.api.metrics.Meter; import io.opentelemetry.context.Context; import io.opentelemetry.context.ContextKey; @@ -35,6 +37,8 @@ public final class RpcClientMetrics implements OperationListener { private static final Logger logger = Logger.getLogger(RpcClientMetrics.class.getName()); private final DoubleHistogram clientDurationHistogram; + private final LongHistogram clientRequestSize; + private final LongHistogram clientResponseSize; private RpcClientMetrics(Meter meter) { DoubleHistogramBuilder durationBuilder = @@ -44,6 +48,24 @@ private RpcClientMetrics(Meter meter) { .setUnit("ms"); RpcMetricsAdvice.applyClientDurationAdvice(durationBuilder); clientDurationHistogram = durationBuilder.build(); + + LongHistogramBuilder requestSizeBuilder = + meter + .histogramBuilder("rpc.client.request.size") + .setUnit("By") + .setDescription("Measures the size of RPC request messages (uncompressed).") + .ofLongs(); + RpcMetricsAdvice.applyClientRequestSizeAdvice(requestSizeBuilder); + clientRequestSize = requestSizeBuilder.build(); + + LongHistogramBuilder responseSizeBuilder = + meter + .histogramBuilder("rpc.client.response.size") + .setUnit("By") + .setDescription("Measures the size of RPC response messages (uncompressed).") + .ofLongs(); + RpcMetricsAdvice.applyClientRequestSizeAdvice(responseSizeBuilder); + clientResponseSize = responseSizeBuilder.build(); } /** @@ -72,10 +94,21 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { context); return; } + Attributes attributes = state.startAttributes().toBuilder().putAll(endAttributes).build(); clientDurationHistogram.record( - (endNanos - state.startTimeNanos()) / NANOS_PER_MS, - state.startAttributes().toBuilder().putAll(endAttributes).build(), - context); + (endNanos - state.startTimeNanos()) / NANOS_PER_MS, attributes, context); + + Long rpcClientRequestBodySize = RpcMessageBodySizeUtil.getRpcClientRequestBodySize( + endAttributes, state.startAttributes()); + if (rpcClientRequestBodySize != null && rpcClientRequestBodySize > 0) { + clientRequestSize.record(rpcClientRequestBodySize, attributes, context); + } + + Long rpcClientResponseBodySize = RpcMessageBodySizeUtil.getRpcClientResponseBodySize( + endAttributes, state.startAttributes()); + if (rpcClientResponseBodySize != null && rpcClientResponseBodySize > 0) { + clientResponseSize.record(rpcClientResponseBodySize, attributes, context); + } } @AutoValue diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java index f731e703586c..a1a1f380fa89 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java @@ -20,6 +20,14 @@ abstract class RpcCommonAttributesExtractor static final AttributeKey RPC_METHOD = AttributeKey.stringKey("rpc.method"); static final AttributeKey RPC_SERVICE = AttributeKey.stringKey("rpc.service"); static final AttributeKey RPC_SYSTEM = AttributeKey.stringKey("rpc.system"); + static final AttributeKey RPC_CLIENT_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.client.request.body.size"); + static final AttributeKey RPC_CLIENT_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.client.response.body.size"); + static final AttributeKey RPC_SERVER_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.server.request.body.size"); + static final AttributeKey RPC_SERVER_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.server.response.body.size"); private final RpcAttributesGetter getter; @@ -41,6 +49,14 @@ public final void onEnd( REQUEST request, @Nullable RESPONSE response, @Nullable Throwable error) { - // No response attributes + internalSet(attributes, RPC_CLIENT_REQUEST_BODY_SIZE, + (long) getter.getClientRequestSize(request)); + internalSet(attributes, RPC_CLIENT_RESPONSE_BODY_SIZE, + (long) getter.getClientResponseSize(request)); + + internalSet(attributes, RPC_SERVER_REQUEST_BODY_SIZE, + (long) getter.getServerRequestSize(request)); + internalSet(attributes, RPC_SERVER_RESPONSE_BODY_SIZE, + (long) getter.getServerResponseSize(request)); } } diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java new file mode 100644 index 000000000000..fb3e99c2856b --- /dev/null +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java @@ -0,0 +1,47 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.incubator.semconv.rpc; + +import io.opentelemetry.api.common.AttributeKey; +import io.opentelemetry.api.common.Attributes; +import javax.annotation.Nullable; + +final class RpcMessageBodySizeUtil { + + @Nullable + static Long getRpcClientRequestBodySize(Attributes... attributesList) { + return getAttribute(RpcCommonAttributesExtractor.RPC_CLIENT_REQUEST_BODY_SIZE, attributesList); + } + + @Nullable + static Long getRpcClientResponseBodySize(Attributes... attributesList) { + return getAttribute( + RpcCommonAttributesExtractor.RPC_CLIENT_RESPONSE_BODY_SIZE, attributesList); + } + + @Nullable + static Long getRpcServerRequestBodySize(Attributes... attributesList) { + return getAttribute(RpcCommonAttributesExtractor.RPC_SERVER_REQUEST_BODY_SIZE, attributesList); + } + @Nullable + static Long getRpcServerResponseBodySize(Attributes... attributesList) { + return getAttribute( + RpcCommonAttributesExtractor.RPC_SERVER_RESPONSE_BODY_SIZE, attributesList); + } + + @Nullable + private static T getAttribute(AttributeKey key, Attributes... attributesList) { + for (Attributes attributes : attributesList) { + T value = attributes.get(key); + if (value != null) { + return value; + } + } + return null; + } + + private RpcMessageBodySizeUtil() {} +} diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java index 0a24cca3f39c..85c12993927c 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java @@ -7,7 +7,9 @@ import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.incubator.metrics.ExtendedDoubleHistogramBuilder; +import io.opentelemetry.api.incubator.metrics.ExtendedLongHistogramBuilder; import io.opentelemetry.api.metrics.DoubleHistogramBuilder; +import io.opentelemetry.api.metrics.LongHistogramBuilder; import io.opentelemetry.semconv.NetworkAttributes; import io.opentelemetry.semconv.ServerAttributes; import java.util.Arrays; @@ -55,6 +57,43 @@ static void applyServerDurationAdvice(DoubleHistogramBuilder builder) { ServerAttributes.SERVER_ADDRESS, ServerAttributes.SERVER_PORT)); } + static void applyClientRequestSizeAdvice(LongHistogramBuilder builder) { + if (!(builder instanceof ExtendedLongHistogramBuilder)) { + return; + } + // the list of recommended metrics attributes is from + // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-metrics.md + ((ExtendedLongHistogramBuilder) builder) + .setAttributesAdvice( + Arrays.asList( + RpcCommonAttributesExtractor.RPC_SYSTEM, + RpcCommonAttributesExtractor.RPC_SERVICE, + RpcCommonAttributesExtractor.RPC_METHOD, + RPC_GRPC_STATUS_CODE, + NetworkAttributes.NETWORK_TYPE, + NetworkAttributes.NETWORK_TRANSPORT, + ServerAttributes.SERVER_ADDRESS, + ServerAttributes.SERVER_PORT)); + } + + static void applyServerRequestSizeAdvice(LongHistogramBuilder builder) { + if (!(builder instanceof ExtendedLongHistogramBuilder)) { + return; + } + // the list of recommended metrics attributes is from + // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-metrics.md + ((ExtendedLongHistogramBuilder) builder) + .setAttributesAdvice( + Arrays.asList( + RpcCommonAttributesExtractor.RPC_SYSTEM, + RpcCommonAttributesExtractor.RPC_SERVICE, + RpcCommonAttributesExtractor.RPC_METHOD, + RPC_GRPC_STATUS_CODE, + NetworkAttributes.NETWORK_TYPE, + NetworkAttributes.NETWORK_TRANSPORT, + ServerAttributes.SERVER_ADDRESS, + ServerAttributes.SERVER_PORT)); + } private RpcMetricsAdvice() {} } diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java index 526db167bdfd..e93871932111 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java @@ -11,6 +11,8 @@ import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.metrics.DoubleHistogram; import io.opentelemetry.api.metrics.DoubleHistogramBuilder; +import io.opentelemetry.api.metrics.LongHistogram; +import io.opentelemetry.api.metrics.LongHistogramBuilder; import io.opentelemetry.api.metrics.Meter; import io.opentelemetry.context.Context; import io.opentelemetry.context.ContextKey; @@ -35,6 +37,8 @@ public final class RpcServerMetrics implements OperationListener { private static final Logger logger = Logger.getLogger(RpcServerMetrics.class.getName()); private final DoubleHistogram serverDurationHistogram; + private final LongHistogram serverRequestSize; + private final LongHistogram serverResponseSize; private RpcServerMetrics(Meter meter) { DoubleHistogramBuilder durationBuilder = @@ -44,6 +48,24 @@ private RpcServerMetrics(Meter meter) { .setUnit("ms"); RpcMetricsAdvice.applyServerDurationAdvice(durationBuilder); serverDurationHistogram = durationBuilder.build(); + + LongHistogramBuilder requestSizeBuilder = + meter + .histogramBuilder("rpc.server.request.size") + .setUnit("By") + .setDescription("Measures the size of RPC request messages (uncompressed).") + .ofLongs(); + RpcMetricsAdvice.applyServerRequestSizeAdvice(requestSizeBuilder); + serverRequestSize = requestSizeBuilder.build(); + + LongHistogramBuilder responseSizeBuilder = + meter + .histogramBuilder("rpc.server.response.size") + .setUnit("By") + .setDescription("Measures the size of RPC response messages (uncompressed).") + .ofLongs(); + RpcMetricsAdvice.applyServerRequestSizeAdvice(responseSizeBuilder); + serverResponseSize = responseSizeBuilder.build(); } /** @@ -72,10 +94,21 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { context); return; } + Attributes attributes = state.startAttributes().toBuilder().putAll(endAttributes).build(); serverDurationHistogram.record( - (endNanos - state.startTimeNanos()) / NANOS_PER_MS, - state.startAttributes().toBuilder().putAll(endAttributes).build(), - context); + (endNanos - state.startTimeNanos()) / NANOS_PER_MS, attributes, context); + + Long rpcServerRequestBodySize = RpcMessageBodySizeUtil.getRpcServerRequestBodySize( + endAttributes, state.startAttributes()); + if (rpcServerRequestBodySize != null && rpcServerRequestBodySize >0 ) { + serverRequestSize.record(rpcServerRequestBodySize, attributes, context); + } + + Long rpcServerResponseBodySize = RpcMessageBodySizeUtil.getRpcServerResponseBodySize( + endAttributes, state.startAttributes()); + if (rpcServerResponseBodySize != null && rpcServerResponseBodySize > 0) { + serverResponseSize.record(rpcServerResponseBodySize, attributes, context); + } } @AutoValue diff --git a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java index 768a67de0bb2..da697c6785ce 100644 --- a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java +++ b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java @@ -16,6 +16,7 @@ import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; import io.opentelemetry.sdk.metrics.SdkMeterProvider; +import io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; import io.opentelemetry.semconv.NetworkAttributes; import io.opentelemetry.semconv.ServerAttributes; @@ -46,6 +47,8 @@ void collectsMetrics() { .put(ServerAttributes.SERVER_PORT, 8080) .put(NetworkAttributes.NETWORK_TRANSPORT, "tcp") .put(NetworkAttributes.NETWORK_TYPE, "ipv4") + .put(RpcCommonAttributesExtractor.RPC_CLIENT_REQUEST_BODY_SIZE, 10) + .put(RpcCommonAttributesExtractor.RPC_CLIENT_RESPONSE_BODY_SIZE, 20) .build(); Attributes responseAttributes2 = @@ -76,6 +79,60 @@ void collectsMetrics() { assertThat(metricReader.collectAllMetrics()) .satisfiesExactlyInAnyOrder( + metric -> + OpenTelemetryAssertions.assertThat(metric) + .hasName("rpc.client.response.size") + .hasUnit("By") + .hasDescription("Measures the size of RPC response messages (uncompressed).") + .hasHistogramSatisfying( + histogram -> + histogram.hasPointsSatisfying( + point -> + point.hasSum(20 /* bytes */) + .hasAttributesSatisfying( + equalTo(RpcIncubatingAttributes.RPC_SYSTEM, "grpc"), + equalTo( + RpcIncubatingAttributes.RPC_SERVICE, + "myservice.EchoService"), + equalTo( + RpcIncubatingAttributes.RPC_METHOD, + "exampleMethod"), + equalTo(ServerAttributes.SERVER_ADDRESS, "example.com"), + equalTo(ServerAttributes.SERVER_PORT, 8080), + equalTo(NetworkAttributes.NETWORK_TRANSPORT, "tcp"), + equalTo(NetworkAttributes.NETWORK_TYPE, "ipv4")) + .hasExemplarsSatisfying( + exemplar -> + exemplar + .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") + .hasSpanId("090a0b0c0d0e0f00")))), + metric -> + OpenTelemetryAssertions.assertThat(metric) + .hasName("rpc.client.request.size") + .hasUnit("By") + .hasDescription("Measures the size of RPC request messages (uncompressed).") + .hasHistogramSatisfying( + histogram -> + histogram.hasPointsSatisfying( + point -> + point.hasSum(10 /* bytes */) + .hasAttributesSatisfying( + equalTo(RpcIncubatingAttributes.RPC_SYSTEM, "grpc"), + equalTo( + RpcIncubatingAttributes.RPC_SERVICE, + "myservice.EchoService"), + equalTo( + RpcIncubatingAttributes.RPC_METHOD, + "exampleMethod"), + equalTo(ServerAttributes.SERVER_ADDRESS, "example.com"), + equalTo(ServerAttributes.SERVER_PORT, 8080), + equalTo(NetworkAttributes.NETWORK_TRANSPORT, "tcp"), + equalTo(NetworkAttributes.NETWORK_TYPE, "ipv4")) + .hasExemplarsSatisfying( + exemplar -> + exemplar + .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") + .hasSpanId("090a0b0c0d0e0f00")))), metric -> assertThat(metric) .hasName("rpc.client.duration") diff --git a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java index bb8b59082aa5..9694076ba2c0 100644 --- a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java +++ b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java @@ -16,6 +16,7 @@ import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; import io.opentelemetry.sdk.metrics.SdkMeterProvider; +import io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; import io.opentelemetry.semconv.NetworkAttributes; import io.opentelemetry.semconv.ServerAttributes; @@ -47,6 +48,8 @@ void collectsMetrics() { .put(NetworkAttributes.NETWORK_LOCAL_ADDRESS, "127.0.0.1") .put(NetworkAttributes.NETWORK_TRANSPORT, "tcp") .put(NetworkAttributes.NETWORK_TYPE, "ipv4") + .put(RpcCommonAttributesExtractor.RPC_SERVER_REQUEST_BODY_SIZE, 10) + .put(RpcCommonAttributesExtractor.RPC_SERVER_RESPONSE_BODY_SIZE, 20) .build(); Attributes responseAttributes2 = @@ -88,6 +91,58 @@ void collectsMetrics() { point -> point .hasSum(150 /* millis */) + .hasAttributesSatisfying( + equalTo(RpcIncubatingAttributes.RPC_SYSTEM, "grpc"), + equalTo( + RpcIncubatingAttributes.RPC_SERVICE, + "myservice.EchoService"), + equalTo( + RpcIncubatingAttributes.RPC_METHOD, + "exampleMethod"), + equalTo(ServerAttributes.SERVER_ADDRESS, "example.com"), + equalTo(NetworkAttributes.NETWORK_TRANSPORT, "tcp"), + equalTo(NetworkAttributes.NETWORK_TYPE, "ipv4")) + .hasExemplarsSatisfying( + exemplar -> + exemplar + .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") + .hasSpanId("090a0b0c0d0e0f00")))), + metric -> + OpenTelemetryAssertions.assertThat(metric) + .hasName("rpc.server.response.size") + .hasUnit("By") + .hasDescription("Measures the size of RPC response messages (uncompressed).") + .hasHistogramSatisfying( + histogram -> + histogram.hasPointsSatisfying( + point -> + point.hasSum(20 /* bytes */) + .hasAttributesSatisfying( + equalTo(RpcIncubatingAttributes.RPC_SYSTEM, "grpc"), + equalTo( + RpcIncubatingAttributes.RPC_SERVICE, + "myservice.EchoService"), + equalTo( + RpcIncubatingAttributes.RPC_METHOD, + "exampleMethod"), + equalTo(ServerAttributes.SERVER_ADDRESS, "example.com"), + equalTo(NetworkAttributes.NETWORK_TRANSPORT, "tcp"), + equalTo(NetworkAttributes.NETWORK_TYPE, "ipv4")) + .hasExemplarsSatisfying( + exemplar -> + exemplar + .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") + .hasSpanId("090a0b0c0d0e0f00")))), + metric -> + OpenTelemetryAssertions.assertThat(metric) + .hasName("rpc.server.request.size") + .hasUnit("By") + .hasDescription("Measures the size of RPC request messages (uncompressed).") + .hasHistogramSatisfying( + histogram -> + histogram.hasPointsSatisfying( + point -> + point.hasSum(10 /* bytes */) .hasAttributesSatisfying( equalTo(RpcIncubatingAttributes.RPC_SYSTEM, "grpc"), equalTo( diff --git a/instrumentation/grpc-1.6/library/build.gradle.kts b/instrumentation/grpc-1.6/library/build.gradle.kts index 00ace4566efb..c8db501eb27f 100644 --- a/instrumentation/grpc-1.6/library/build.gradle.kts +++ b/instrumentation/grpc-1.6/library/build.gradle.kts @@ -7,6 +7,7 @@ val grpcVersion = "1.6.0" dependencies { library("io.grpc:grpc-core:$grpcVersion") + library("com.google.protobuf:protobuf-java:3.25.3") testLibrary("io.grpc:grpc-netty:$grpcVersion") testLibrary("io.grpc:grpc-protobuf:$grpcVersion") diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/BodySizeUtil.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/BodySizeUtil.java new file mode 100644 index 000000000000..536a92888330 --- /dev/null +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/BodySizeUtil.java @@ -0,0 +1,22 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.grpc.v1_6; + +import com.google.protobuf.MessageLite; + +final class BodySizeUtil { + + static int getBodySize(T message) { + if (message instanceof MessageLite) { + return ((MessageLite) message).getSerializedSize(); + } else { + // Message is not a protobuf message + return 0; + } + } + + private BodySizeUtil() {} +} diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java index 89f6746e1ceb..57d2eafd10e8 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java @@ -20,6 +20,11 @@ public final class GrpcRequest { private volatile int logicalPort = -1; @Nullable private volatile SocketAddress peerSocketAddress; + private int clientRequestSize; + private int clientResponseSize; + + private int serverRequestSize; + private int serverResponseSize; GrpcRequest( MethodDescriptor method, @Nullable Metadata metadata, @@ -78,4 +83,36 @@ public SocketAddress getPeerSocketAddress() { void setPeerSocketAddress(SocketAddress peerSocketAddress) { this.peerSocketAddress = peerSocketAddress; } + + public int getClientRequestSize() { + return clientRequestSize; + } + + void setClientRequestSize(int clientRequestSize) { + this.clientRequestSize = clientRequestSize; + } + + public int getClientResponseSize() { + return clientResponseSize; + } + + void setClientResponseSize(int clientResponseSize) { + this.clientResponseSize = clientResponseSize; + } + + public int getServerRequestSize() { + return serverRequestSize; + } + + public void setServerRequestSize(int serverRequestSize) { + this.serverRequestSize = serverRequestSize; + } + + public int getServerResponseSize() { + return serverResponseSize; + } + + public void setServerResponseSize(int serverResponseSize) { + this.serverResponseSize = serverResponseSize; + } } diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java index ee7214bb1a87..955cef4f8904 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java @@ -43,6 +43,27 @@ public String getMethod(GrpcRequest request) { return fullMethodName.substring(slashIndex + 1); } + @Override + public int getClientRequestSize(GrpcRequest request) { + return request.getClientRequestSize(); + } + + @Override + public int getClientResponseSize(GrpcRequest request) { + return request.getClientResponseSize(); + } + + @Override + public int getServerRequestSize(GrpcRequest request) { + return request.getServerRequestSize(); + } + + @Override + public int getServerResponseSize(GrpcRequest request) { + return request.getServerResponseSize(); + } + + List metadataValue(GrpcRequest request, String key) { if (request.getMetadata() == null) { return Collections.emptyList(); diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingClientInterceptor.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingClientInterceptor.java index 7e89b193b54a..4b3a888e5799 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingClientInterceptor.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingClientInterceptor.java @@ -126,6 +126,7 @@ public void start(Listener responseListener, Metadata headers) { @Override public void sendMessage(REQUEST message) { + request.setClientRequestSize(BodySizeUtil.getBodySize(message)); try (Scope ignored = context.makeCurrent()) { super.sendMessage(message); } catch (Throwable e) { @@ -159,6 +160,7 @@ final class TracingClientCallListener @Override public void onMessage(RESPONSE message) { + request.setClientResponseSize(BodySizeUtil.getBodySize(message)); long messageId = RECEIVED_MESSAGE_ID_UPDATER.incrementAndGet(TracingClientCall.this); if (emitMessageEvents) { Attributes attributes = Attributes.of(MESSAGE_TYPE, RECEIVED, MESSAGE_ID, messageId); diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingServerInterceptor.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingServerInterceptor.java index d52c332ec50a..a5eafd0b1ada 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingServerInterceptor.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingServerInterceptor.java @@ -119,6 +119,7 @@ TracingServerCallListener start(Metadata headers, ServerCallHandler Date: Tue, 16 Jul 2024 17:55:18 +0800 Subject: [PATCH 02/24] fix ci --- .../semconv/rpc/RpcClientMetrics.java | 8 ++++---- .../rpc/RpcCommonAttributesExtractor.java | 18 +++++++++--------- .../semconv/rpc/RpcMessageBodySizeUtil.java | 7 +++---- .../semconv/rpc/RpcMetricsAdvice.java | 1 + .../semconv/rpc/RpcServerMetrics.java | 10 +++++----- .../semconv/rpc/RpcClientMetricsTest.java | 6 ++++-- .../semconv/rpc/RpcServerMetricsTest.java | 6 ++++-- 7 files changed, 30 insertions(+), 26 deletions(-) diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java index d6f885b384f9..959dc8a3de6b 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java @@ -98,14 +98,14 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { clientDurationHistogram.record( (endNanos - state.startTimeNanos()) / NANOS_PER_MS, attributes, context); - Long rpcClientRequestBodySize = RpcMessageBodySizeUtil.getRpcClientRequestBodySize( - endAttributes, state.startAttributes()); + Long rpcClientRequestBodySize = + RpcMessageBodySizeUtil.getRpcClientRequestBodySize(endAttributes, state.startAttributes()); if (rpcClientRequestBodySize != null && rpcClientRequestBodySize > 0) { clientRequestSize.record(rpcClientRequestBodySize, attributes, context); } - Long rpcClientResponseBodySize = RpcMessageBodySizeUtil.getRpcClientResponseBodySize( - endAttributes, state.startAttributes()); + Long rpcClientResponseBodySize = + RpcMessageBodySizeUtil.getRpcClientResponseBodySize(endAttributes, state.startAttributes()); if (rpcClientResponseBodySize != null && rpcClientResponseBodySize > 0) { clientResponseSize.record(rpcClientResponseBodySize, attributes, context); } diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java index a1a1f380fa89..9b58b30f3f31 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java @@ -49,14 +49,14 @@ public final void onEnd( REQUEST request, @Nullable RESPONSE response, @Nullable Throwable error) { - internalSet(attributes, RPC_CLIENT_REQUEST_BODY_SIZE, - (long) getter.getClientRequestSize(request)); - internalSet(attributes, RPC_CLIENT_RESPONSE_BODY_SIZE, - (long) getter.getClientResponseSize(request)); - - internalSet(attributes, RPC_SERVER_REQUEST_BODY_SIZE, - (long) getter.getServerRequestSize(request)); - internalSet(attributes, RPC_SERVER_RESPONSE_BODY_SIZE, - (long) getter.getServerResponseSize(request)); + internalSet( + attributes, RPC_CLIENT_REQUEST_BODY_SIZE, (long) getter.getClientRequestSize(request)); + internalSet( + attributes, RPC_CLIENT_RESPONSE_BODY_SIZE, (long) getter.getClientResponseSize(request)); + + internalSet( + attributes, RPC_SERVER_REQUEST_BODY_SIZE, (long) getter.getServerRequestSize(request)); + internalSet( + attributes, RPC_SERVER_RESPONSE_BODY_SIZE, (long) getter.getServerResponseSize(request)); } } diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java index fb3e99c2856b..2baba8a67678 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java @@ -18,18 +18,17 @@ static Long getRpcClientRequestBodySize(Attributes... attributesList) { @Nullable static Long getRpcClientResponseBodySize(Attributes... attributesList) { - return getAttribute( - RpcCommonAttributesExtractor.RPC_CLIENT_RESPONSE_BODY_SIZE, attributesList); + return getAttribute(RpcCommonAttributesExtractor.RPC_CLIENT_RESPONSE_BODY_SIZE, attributesList); } @Nullable static Long getRpcServerRequestBodySize(Attributes... attributesList) { return getAttribute(RpcCommonAttributesExtractor.RPC_SERVER_REQUEST_BODY_SIZE, attributesList); } + @Nullable static Long getRpcServerResponseBodySize(Attributes... attributesList) { - return getAttribute( - RpcCommonAttributesExtractor.RPC_SERVER_RESPONSE_BODY_SIZE, attributesList); + return getAttribute(RpcCommonAttributesExtractor.RPC_SERVER_RESPONSE_BODY_SIZE, attributesList); } @Nullable diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java index 85c12993927c..cae2b376ddd1 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java @@ -57,6 +57,7 @@ static void applyServerDurationAdvice(DoubleHistogramBuilder builder) { ServerAttributes.SERVER_ADDRESS, ServerAttributes.SERVER_PORT)); } + static void applyClientRequestSizeAdvice(LongHistogramBuilder builder) { if (!(builder instanceof ExtendedLongHistogramBuilder)) { return; diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java index e93871932111..572376b3b23d 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java @@ -98,14 +98,14 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { serverDurationHistogram.record( (endNanos - state.startTimeNanos()) / NANOS_PER_MS, attributes, context); - Long rpcServerRequestBodySize = RpcMessageBodySizeUtil.getRpcServerRequestBodySize( - endAttributes, state.startAttributes()); - if (rpcServerRequestBodySize != null && rpcServerRequestBodySize >0 ) { + Long rpcServerRequestBodySize = + RpcMessageBodySizeUtil.getRpcServerRequestBodySize(endAttributes, state.startAttributes()); + if (rpcServerRequestBodySize != null && rpcServerRequestBodySize > 0) { serverRequestSize.record(rpcServerRequestBodySize, attributes, context); } - Long rpcServerResponseBodySize = RpcMessageBodySizeUtil.getRpcServerResponseBodySize( - endAttributes, state.startAttributes()); + Long rpcServerResponseBodySize = + RpcMessageBodySizeUtil.getRpcServerResponseBodySize(endAttributes, state.startAttributes()); if (rpcServerResponseBodySize != null && rpcServerResponseBodySize > 0) { serverResponseSize.record(rpcServerResponseBodySize, attributes, context); } diff --git a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java index da697c6785ce..6506664e69a6 100644 --- a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java +++ b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java @@ -88,7 +88,8 @@ void collectsMetrics() { histogram -> histogram.hasPointsSatisfying( point -> - point.hasSum(20 /* bytes */) + point + .hasSum(20 /* bytes */) .hasAttributesSatisfying( equalTo(RpcIncubatingAttributes.RPC_SYSTEM, "grpc"), equalTo( @@ -115,7 +116,8 @@ void collectsMetrics() { histogram -> histogram.hasPointsSatisfying( point -> - point.hasSum(10 /* bytes */) + point + .hasSum(10 /* bytes */) .hasAttributesSatisfying( equalTo(RpcIncubatingAttributes.RPC_SYSTEM, "grpc"), equalTo( diff --git a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java index 9694076ba2c0..ad598c6f0d26 100644 --- a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java +++ b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java @@ -116,7 +116,8 @@ void collectsMetrics() { histogram -> histogram.hasPointsSatisfying( point -> - point.hasSum(20 /* bytes */) + point + .hasSum(20 /* bytes */) .hasAttributesSatisfying( equalTo(RpcIncubatingAttributes.RPC_SYSTEM, "grpc"), equalTo( @@ -142,7 +143,8 @@ void collectsMetrics() { histogram -> histogram.hasPointsSatisfying( point -> - point.hasSum(10 /* bytes */) + point + .hasSum(10 /* bytes */) .hasAttributesSatisfying( equalTo(RpcIncubatingAttributes.RPC_SYSTEM, "grpc"), equalTo( From 01a1bb038ae54b8257b95491a6d6cca5f7b597df Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Tue, 16 Jul 2024 18:02:22 +0800 Subject: [PATCH 03/24] fix ci --- .../io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java | 1 + .../instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java index 57d2eafd10e8..3faa4cd50c36 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java @@ -25,6 +25,7 @@ public final class GrpcRequest { private int serverRequestSize; private int serverResponseSize; + GrpcRequest( MethodDescriptor method, @Nullable Metadata metadata, diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java index 955cef4f8904..f9b490e65f22 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java @@ -63,7 +63,6 @@ public int getServerResponseSize(GrpcRequest request) { return request.getServerResponseSize(); } - List metadataValue(GrpcRequest request, String key) { if (request.getMetadata() == null) { return Collections.emptyList(); From 6121b3007134ab1df3d1405a9d9bd77308d22ad5 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Tue, 16 Jul 2024 18:35:44 +0800 Subject: [PATCH 04/24] fix ci --- .../rpc/RpcCommonAttributesExtractor.java | 27 ++++++++++++------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java index 9b58b30f3f31..9d61e7c24d32 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java @@ -49,14 +49,23 @@ public final void onEnd( REQUEST request, @Nullable RESPONSE response, @Nullable Throwable error) { - internalSet( - attributes, RPC_CLIENT_REQUEST_BODY_SIZE, (long) getter.getClientRequestSize(request)); - internalSet( - attributes, RPC_CLIENT_RESPONSE_BODY_SIZE, (long) getter.getClientResponseSize(request)); - - internalSet( - attributes, RPC_SERVER_REQUEST_BODY_SIZE, (long) getter.getServerRequestSize(request)); - internalSet( - attributes, RPC_SERVER_RESPONSE_BODY_SIZE, (long) getter.getServerResponseSize(request)); + int clientRequestSize = getter.getClientRequestSize(request); + if (clientRequestSize > 0) { + internalSet(attributes, RPC_CLIENT_REQUEST_BODY_SIZE, (long) clientRequestSize); + } + int clientResponseSize = getter.getClientResponseSize(request); + if (clientResponseSize > 0) { + internalSet(attributes, RPC_CLIENT_RESPONSE_BODY_SIZE, (long) clientResponseSize); + } + + int serverRequestSize = getter.getServerRequestSize(request); + if (serverRequestSize > 0) { + internalSet(attributes, RPC_SERVER_REQUEST_BODY_SIZE, (long) serverRequestSize); + } + + int serverResponseSize = getter.getServerResponseSize(request); + if (serverResponseSize > 0) { + internalSet(attributes, RPC_SERVER_RESPONSE_BODY_SIZE, (long) serverResponseSize); + } } } From 96802194e2579472085c2e85e41636acf986dbec Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Wed, 17 Jul 2024 12:18:30 +0800 Subject: [PATCH 05/24] fix test --- .../armeria/grpc/v1_14/ArmeriaGrpcTest.java | 22 +++- .../grpc/v1_6/AbstractGrpcTest.java | 105 ++++++++++++++---- 2 files changed, 102 insertions(+), 25 deletions(-) diff --git a/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java b/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java index 188dcbcc492a..43f0f4af81f4 100644 --- a/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java +++ b/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java @@ -22,6 +22,7 @@ import example.Helloworld; import io.grpc.Status; import io.grpc.stub.StreamObserver; +import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; import io.opentelemetry.semconv.incubating.MessageIncubatingAttributes; @@ -33,6 +34,15 @@ class ArmeriaGrpcTest { @RegisterExtension static final AgentInstrumentationExtension testing = AgentInstrumentationExtension.create(); + private static final AttributeKey RPC_CLIENT_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.client.request.body.size"); + private static final AttributeKey RPC_CLIENT_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.client.response.body.size"); + private static final AttributeKey RPC_SERVER_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.server.request.body.size"); + private static final AttributeKey RPC_SERVER_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.server.response.body.size"); + @RegisterExtension static final ServerExtension server = new ServerExtension() { @@ -63,12 +73,12 @@ void grpcInstrumentation() { GreeterGrpc.GreeterBlockingStub client = GrpcClients.builder(server.httpUri()).build(GreeterGrpc.GreeterBlockingStub.class); - Helloworld.Response response = - testing.runWithSpan( - "parent", - () -> client.sayHello(Helloworld.Request.newBuilder().setName("test").build())); + Helloworld.Request request = Helloworld.Request.newBuilder().setName("test").build(); + Helloworld.Response response = testing.runWithSpan("parent", () -> client.sayHello(request)); assertThat(response.getMessage()).isEqualTo("Hello test"); + int requestSerializedSize = request.getSerializedSize(); + int responseSerializedSize = response.getSerializedSize(); testing.waitAndAssertTraces( trace -> @@ -85,6 +95,8 @@ void grpcInstrumentation() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "127.0.0.1"), equalTo(SERVER_PORT, (long) server.httpPort())) + equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize)) .hasEventsSatisfyingExactly( event -> event @@ -110,6 +122,8 @@ void grpcInstrumentation() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "127.0.0.1"), equalTo(SERVER_PORT, server.httpPort())) + equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize)) .hasEventsSatisfyingExactly( event -> event diff --git a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java index 31db3557c5b8..a70ef684824a 100644 --- a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java +++ b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java @@ -85,6 +85,15 @@ public abstract class AbstractGrpcTest { protected static final String SERVER_REQUEST_METADATA_KEY = "some-server-key"; + private static final AttributeKey RPC_CLIENT_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.client.request.body.size"); + private static final AttributeKey RPC_CLIENT_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.client.response.body.size"); + private static final AttributeKey RPC_SERVER_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.server.request.body.size"); + private static final AttributeKey RPC_SERVER_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.server.response.body.size"); + protected abstract ServerBuilder configureServer(ServerBuilder server); protected abstract ManagedChannelBuilder configureClient(ManagedChannelBuilder client); @@ -127,7 +136,9 @@ public void sayHello( "parent", () -> client.sayHello(Helloworld.Request.newBuilder().setName(paramName).build())); - assertThat(response.getMessage()).isEqualTo("Hello " + paramName); + String prefix = "Hello "; + assertThat(response.getMessage()).isEqualTo(prefix + paramName); + int responseSerializedSize = response.getSerializedSize(); testing() .waitAndAssertTraces( @@ -146,6 +157,10 @@ public void sayHello( equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) + equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo( + RPC_CLIENT_REQUEST_BODY_SIZE, + responseSerializedSize - prefix.length()), .hasEventsSatisfyingExactly( event -> event @@ -176,6 +191,10 @@ public void sayHello( equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) + equalTo( + RPC_SERVER_RESPONSE_BODY_SIZE, + responseSerializedSize - prefix.length()), + equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -260,13 +279,14 @@ public void sayHello( AtomicReference response = new AtomicReference<>(); AtomicReference error = new AtomicReference<>(); + Helloworld.Request request = Helloworld.Request.newBuilder().setName("test").build(); testing() .runWithSpan( "parent", () -> { ListenableFuture future = Futures.transform( - client.sayHello(Helloworld.Request.newBuilder().setName("test").build()), + client.sayHello(request), resp -> { testing().runWithSpan("child", () -> {}); return resp; @@ -280,7 +300,10 @@ public void sayHello( }); assertThat(error).hasValue(null); - assertThat(response.get().getMessage()).isEqualTo("Hello test"); + Helloworld.Response res = response.get(); + assertThat(res.getMessage()).isEqualTo("Hello test"); + int requestSerializedSize = request.getSerializedSize(); + int responseSerializedSize = res.getSerializedSize(); testing() .waitAndAssertTraces( @@ -299,6 +322,8 @@ public void sayHello( equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) + equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -328,6 +353,8 @@ public void sayHello( equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), + equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -418,12 +445,13 @@ public void sayHello( AtomicReference response = new AtomicReference<>(); AtomicReference error = new AtomicReference<>(); CountDownLatch latch = new CountDownLatch(1); + Helloworld.Request request = Helloworld.Request.newBuilder().setName("test").build(); testing() .runWithSpan( "parent", () -> client.sayHello( - Helloworld.Request.newBuilder().setName("test").build(), + request, new StreamObserver() { @Override public void onNext(Helloworld.Response r) { @@ -445,7 +473,10 @@ public void onCompleted() { latch.await(10, TimeUnit.SECONDS); assertThat(error).hasValue(null); - assertThat(response.get().getMessage()).isEqualTo("Hello test"); + Helloworld.Response res = response.get(); + assertThat(res.getMessage()).isEqualTo("Hello test"); + int requestSerializedSize = request.getSerializedSize(); + int responseSerializedSize = res.getSerializedSize(); testing() .waitAndAssertTraces( @@ -464,6 +495,8 @@ public void onCompleted() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) + equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -493,6 +526,8 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), + equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -577,8 +612,9 @@ public void sayHello( GreeterGrpc.GreeterBlockingStub client = GreeterGrpc.newBlockingStub(channel); - assertThatThrownBy( - () -> client.sayHello(Helloworld.Request.newBuilder().setName("error").build())) + Helloworld.Request request = Helloworld.Request.newBuilder().setName("error").build(); + int requestSerializedSize = request.getSerializedSize(); + assertThatThrownBy(() -> client.sayHello(request)) .isInstanceOfSatisfying( StatusRuntimeException.class, t -> { @@ -604,6 +640,7 @@ public void sayHello( equalTo(RPC_GRPC_STATUS_CODE, (long) status.getCode().value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) + equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -626,6 +663,7 @@ public void sayHello( equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), + equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfying( events -> { @@ -705,9 +743,9 @@ public void sayHello( closer.add(() -> server.shutdownNow().awaitTermination()); GreeterGrpc.GreeterBlockingStub client = GreeterGrpc.newBlockingStub(channel); - - assertThatThrownBy( - () -> client.sayHello(Helloworld.Request.newBuilder().setName("error").build())) + Helloworld.Request request = Helloworld.Request.newBuilder().setName("error").build(); + int requestSerializedSize = request.getSerializedSize(); + assertThatThrownBy(() -> client.sayHello(request)) .isInstanceOfSatisfying( StatusRuntimeException.class, t -> { @@ -743,6 +781,7 @@ public void sayHello( (long) Status.UNKNOWN.getCode().value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) + equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -765,6 +804,7 @@ public void sayHello( equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), + equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfying( events -> { @@ -918,12 +958,13 @@ public ClientCall interceptCall( AtomicReference response = new AtomicReference<>(); AtomicReference error = new AtomicReference<>(); CountDownLatch latch = new CountDownLatch(1); + Helloworld.Request request = Helloworld.Request.newBuilder().setName("test").build(); testing() .runWithSpan( "parent", () -> client.sayHello( - Helloworld.Request.newBuilder().setName("test").build(), + request, new StreamObserver() { @Override public void onNext(Helloworld.Response r) { @@ -954,7 +995,10 @@ public void onCompleted() { latch.await(10, TimeUnit.SECONDS); assertThat(error).hasValue(null); - assertThat(response.get().getMessage()).isEqualTo("Hello test"); + Helloworld.Response res = response.get(); + assertThat(res.getMessage()).isEqualTo("Hello test"); + int requestSerializedSize = request.getSerializedSize(); + int responseSerializedSize = res.getSerializedSize(); testing() .waitAndAssertTraces( @@ -973,6 +1017,8 @@ public void onCompleted() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) + equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -1002,6 +1048,8 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), + equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -1043,12 +1091,13 @@ public void sayMultipleHello( IllegalStateException thrown = new IllegalStateException("illegal"); AtomicReference error = new AtomicReference<>(); CountDownLatch latch = new CountDownLatch(1); + Helloworld.Request request = Helloworld.Request.newBuilder().setName("test").build(); testing() .runWithSpan( "parent", () -> client.sayMultipleHello( - Helloworld.Request.newBuilder().setName("test").build(), + request, new StreamObserver() { @Override public void onNext(Helloworld.Response r) { @@ -1071,6 +1120,7 @@ public void onCompleted() { latch.await(10, TimeUnit.SECONDS); assertThat(error.get()).isNotNull(); + int requestSerializedSize = request.getSerializedSize(); testing() .waitAndAssertTraces( @@ -1091,6 +1141,7 @@ public void onCompleted() { RPC_GRPC_STATUS_CODE, (long) Status.Code.CANCELLED.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) + equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfying( events -> { assertThat(events).hasSize(3); @@ -1120,6 +1171,7 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), + equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -1175,17 +1227,21 @@ public void onCompleted() { } }); - request.onNext( + ServerReflectionRequest serverReflectionRequest = ServerReflectionRequest.newBuilder() .setListServices("The content will not be checked?") - .build()); + .build(); + request.onNext(serverReflectionRequest); request.onCompleted(); latch.await(10, TimeUnit.SECONDS); assertThat(error).hasValue(null); - assertThat(response.get().getListServicesResponse().getService(0).getName()) + ServerReflectionResponse serverReflectionResponse = response.get(); + assertThat(serverReflectionResponse.getListServicesResponse().getService(0).getName()) .isEqualTo("grpc.reflection.v1alpha.ServerReflection"); + int requestSerializedSize = serverReflectionRequest.getSerializedSize(); + int responseSerializedSize = serverReflectionResponse.getSerializedSize(); testing() .waitAndAssertTraces( @@ -1205,6 +1261,8 @@ public void onCompleted() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) + equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize))) .hasEventsSatisfyingExactly( event -> event @@ -1235,6 +1293,8 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), + equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -1282,13 +1342,12 @@ public void sayHello( GreeterGrpc.GreeterBlockingStub client = GreeterGrpc.newBlockingStub(channel); - Helloworld.Response response = - testing() - .runWithSpan( - "parent", - () -> client.sayHello(Helloworld.Request.newBuilder().setName("test").build())); + Helloworld.Request request = Helloworld.Request.newBuilder().setName("test").build(); + Helloworld.Response response = testing().runWithSpan("parent", () -> client.sayHello(request)); assertThat(response.getMessage()).isEqualTo("Hello test"); + int requestSerializedSize = request.getSerializedSize(); + int responseSerializedSize = response.getSerializedSize(); testing() .waitAndAssertTraces( @@ -1307,6 +1366,8 @@ public void sayHello( equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) + equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -1336,6 +1397,8 @@ public void sayHello( equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), + equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> From cce97f192ef02726790277f5137d0697b4917627 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Wed, 17 Jul 2024 14:10:46 +0800 Subject: [PATCH 06/24] fix ci --- instrumentation/grpc-1.6/library/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/instrumentation/grpc-1.6/library/build.gradle.kts b/instrumentation/grpc-1.6/library/build.gradle.kts index c8db501eb27f..2a5e5c810496 100644 --- a/instrumentation/grpc-1.6/library/build.gradle.kts +++ b/instrumentation/grpc-1.6/library/build.gradle.kts @@ -7,7 +7,7 @@ val grpcVersion = "1.6.0" dependencies { library("io.grpc:grpc-core:$grpcVersion") - library("com.google.protobuf:protobuf-java:3.25.3") + compileOnly("com.google.protobuf:protobuf-java:3.25.3") testLibrary("io.grpc:grpc-netty:$grpcVersion") testLibrary("io.grpc:grpc-protobuf:$grpcVersion") From 22a791f3540f1a95728fa31d77c3df1c1e1d199a Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Wed, 17 Jul 2024 14:43:24 +0800 Subject: [PATCH 07/24] fix muzzle --- instrumentation/grpc-1.6/library/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/instrumentation/grpc-1.6/library/build.gradle.kts b/instrumentation/grpc-1.6/library/build.gradle.kts index 2a5e5c810496..929a1ec1d3f8 100644 --- a/instrumentation/grpc-1.6/library/build.gradle.kts +++ b/instrumentation/grpc-1.6/library/build.gradle.kts @@ -7,7 +7,7 @@ val grpcVersion = "1.6.0" dependencies { library("io.grpc:grpc-core:$grpcVersion") - compileOnly("com.google.protobuf:protobuf-java:3.25.3") + implementation("com.google.protobuf:protobuf-java:3.25.3") testLibrary("io.grpc:grpc-netty:$grpcVersion") testLibrary("io.grpc:grpc-protobuf:$grpcVersion") From c5c46dde79d1efaa27f9d775dbd86c5d87754ad2 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Wed, 17 Jul 2024 15:01:08 +0800 Subject: [PATCH 08/24] fix muzzle --- instrumentation/grpc-1.6/javaagent/build.gradle.kts | 2 ++ instrumentation/grpc-1.6/library/build.gradle.kts | 1 - 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/instrumentation/grpc-1.6/javaagent/build.gradle.kts b/instrumentation/grpc-1.6/javaagent/build.gradle.kts index 671fdb315e90..e2ad01601966 100644 --- a/instrumentation/grpc-1.6/javaagent/build.gradle.kts +++ b/instrumentation/grpc-1.6/javaagent/build.gradle.kts @@ -8,6 +8,7 @@ muzzle { module.set("grpc-core") versions.set("[1.6.0,)") assertInverse.set(true) + extraDependency("com.google.protobuf:protobuf-java:3.25.3") } } @@ -17,6 +18,7 @@ dependencies { implementation(project(":instrumentation:grpc-1.6:library")) library("io.grpc:grpc-core:$grpcVersion") + library("com.google.protobuf:protobuf-java:3.25.3") testInstrumentation(project(":instrumentation:netty:netty-4.1:javaagent")) diff --git a/instrumentation/grpc-1.6/library/build.gradle.kts b/instrumentation/grpc-1.6/library/build.gradle.kts index 929a1ec1d3f8..00ace4566efb 100644 --- a/instrumentation/grpc-1.6/library/build.gradle.kts +++ b/instrumentation/grpc-1.6/library/build.gradle.kts @@ -7,7 +7,6 @@ val grpcVersion = "1.6.0" dependencies { library("io.grpc:grpc-core:$grpcVersion") - implementation("com.google.protobuf:protobuf-java:3.25.3") testLibrary("io.grpc:grpc-netty:$grpcVersion") testLibrary("io.grpc:grpc-protobuf:$grpcVersion") From d17a36c49a068cdbf2ce37d4eb253a1e401292fc Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Wed, 17 Jul 2024 15:07:32 +0800 Subject: [PATCH 09/24] fix muzzle --- instrumentation/grpc-1.6/library/build.gradle.kts | 1 + 1 file changed, 1 insertion(+) diff --git a/instrumentation/grpc-1.6/library/build.gradle.kts b/instrumentation/grpc-1.6/library/build.gradle.kts index 00ace4566efb..c8db501eb27f 100644 --- a/instrumentation/grpc-1.6/library/build.gradle.kts +++ b/instrumentation/grpc-1.6/library/build.gradle.kts @@ -7,6 +7,7 @@ val grpcVersion = "1.6.0" dependencies { library("io.grpc:grpc-core:$grpcVersion") + library("com.google.protobuf:protobuf-java:3.25.3") testLibrary("io.grpc:grpc-netty:$grpcVersion") testLibrary("io.grpc:grpc-protobuf:$grpcVersion") From 9f6055ddd0ab1669c768b816a1fbea96dea18246 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Wed, 17 Jul 2024 17:51:34 +0800 Subject: [PATCH 10/24] fix ci --- .../opentelemetry-instrumentation-api.txt | 2 +- .../grpc/v1_6/AbstractGrpcStreamingTest.java | 17 +++++++++++++++++ 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-api.txt b/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-api.txt index 7f6c2469d18e..7ada78cc00ef 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-api.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-api.txt @@ -1,2 +1,2 @@ Comparing source compatibility of opentelemetry-instrumentation-api-2.19.0-SNAPSHOT.jar against opentelemetry-instrumentation-api-2.18.1.jar -No changes. \ No newline at end of file +No changes. diff --git a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java index 57806ccb0d3d..961b16ec0606 100644 --- a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java +++ b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java @@ -28,6 +28,7 @@ import io.grpc.ServerBuilder; import io.grpc.Status; import io.grpc.stub.StreamObserver; +import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.trace.Span; import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.api.trace.Tracer; @@ -52,6 +53,15 @@ public abstract class AbstractGrpcStreamingTest { + private static final AttributeKey RPC_CLIENT_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.client.request.body.size"); + private static final AttributeKey RPC_CLIENT_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.client.response.body.size"); + private static final AttributeKey RPC_SERVER_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.server.request.body.size"); + private static final AttributeKey RPC_SERVER_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.server.response.body.size"); + protected abstract ServerBuilder configureServer(ServerBuilder server); protected abstract ManagedChannelBuilder configureClient(ManagedChannelBuilder client); @@ -159,6 +169,9 @@ public void onCompleted() { .sorted() .collect(Collectors.toList())); + Helloworld.Response message = Helloworld.Response.newBuilder().setMessage("call " + 1).build(); + int requestSerializedSize = message.getSerializedSize(); + List> clientEvents = new ArrayList<>(); List> serverEvents = new ArrayList<>(); for (long i = 0; i < clientMessageCount; i++) { @@ -229,6 +242,8 @@ public void onCompleted() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) + equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), .satisfies( spanData -> assertThat(spanData.getEvents()) @@ -246,6 +261,8 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), + equalTo(RPC_SERVER_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .satisfies( spanData -> From b9f6cee126bf62c3b8c42329252153b3264b7710 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Wed, 17 Jul 2024 18:32:46 +0800 Subject: [PATCH 11/24] fix ci --- .../opentelemetry-instrumentation-annotations.txt | 2 +- .../opentelemetry-spring-boot-autoconfigure.txt | 2 +- .../current_vs_latest/opentelemetry-spring-boot-starter.txt | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-annotations.txt b/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-annotations.txt index e1d0a8a76701..62ab6f578fc2 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-annotations.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-annotations.txt @@ -1,2 +1,2 @@ Comparing source compatibility of opentelemetry-instrumentation-annotations-2.19.0-SNAPSHOT.jar against opentelemetry-instrumentation-annotations-2.18.1.jar -No changes. \ No newline at end of file +No changes. diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-autoconfigure.txt b/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-autoconfigure.txt index 1bd91e0f9c39..8c2f4c7332bf 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-autoconfigure.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-autoconfigure.txt @@ -1,2 +1,2 @@ Comparing source compatibility of opentelemetry-spring-boot-autoconfigure-2.19.0-SNAPSHOT.jar against opentelemetry-spring-boot-autoconfigure-2.18.1.jar -No changes. \ No newline at end of file +No changes. diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-starter.txt b/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-starter.txt index 85aa35209a8a..2dea386b43c3 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-starter.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-starter.txt @@ -1,2 +1,2 @@ Comparing source compatibility of opentelemetry-spring-boot-starter-2.19.0-SNAPSHOT.jar against opentelemetry-spring-boot-starter-2.18.1.jar -No changes. \ No newline at end of file +No changes. From fcc446844d928087b7f02ea613fb09ede9c8cee4 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Thu, 18 Jul 2024 16:30:31 +0800 Subject: [PATCH 12/24] fix ci --- instrumentation/grpc-1.6/testing/build.gradle.kts | 1 + 1 file changed, 1 insertion(+) diff --git a/instrumentation/grpc-1.6/testing/build.gradle.kts b/instrumentation/grpc-1.6/testing/build.gradle.kts index 259d70dbb53e..69c796bfaebf 100644 --- a/instrumentation/grpc-1.6/testing/build.gradle.kts +++ b/instrumentation/grpc-1.6/testing/build.gradle.kts @@ -16,6 +16,7 @@ dependencies { api("io.grpc:grpc-stub:$grpcVersion") implementation("javax.annotation:javax.annotation-api:1.3.2") + implementation("com.google.protobuf:protobuf-java:3.25.3") implementation("com.google.guava:guava") From 6dc7346387b386db1188cc330ba21e23ccf6d046 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Thu, 18 Jul 2024 16:49:32 +0800 Subject: [PATCH 13/24] revert ci --- instrumentation/grpc-1.6/testing/build.gradle.kts | 1 - 1 file changed, 1 deletion(-) diff --git a/instrumentation/grpc-1.6/testing/build.gradle.kts b/instrumentation/grpc-1.6/testing/build.gradle.kts index 69c796bfaebf..259d70dbb53e 100644 --- a/instrumentation/grpc-1.6/testing/build.gradle.kts +++ b/instrumentation/grpc-1.6/testing/build.gradle.kts @@ -16,7 +16,6 @@ dependencies { api("io.grpc:grpc-stub:$grpcVersion") implementation("javax.annotation:javax.annotation-api:1.3.2") - implementation("com.google.protobuf:protobuf-java:3.25.3") implementation("com.google.guava:guava") From 9b350b4f43ac0958abed3c4f956327385358d6d7 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Thu, 18 Jul 2024 18:41:51 +0800 Subject: [PATCH 14/24] revert ci --- instrumentation/grpc-1.6/javaagent/build.gradle.kts | 4 +--- instrumentation/grpc-1.6/library/build.gradle.kts | 3 +-- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/instrumentation/grpc-1.6/javaagent/build.gradle.kts b/instrumentation/grpc-1.6/javaagent/build.gradle.kts index e2ad01601966..d942aacf1100 100644 --- a/instrumentation/grpc-1.6/javaagent/build.gradle.kts +++ b/instrumentation/grpc-1.6/javaagent/build.gradle.kts @@ -8,7 +8,6 @@ muzzle { module.set("grpc-core") versions.set("[1.6.0,)") assertInverse.set(true) - extraDependency("com.google.protobuf:protobuf-java:3.25.3") } } @@ -18,12 +17,11 @@ dependencies { implementation(project(":instrumentation:grpc-1.6:library")) library("io.grpc:grpc-core:$grpcVersion") - library("com.google.protobuf:protobuf-java:3.25.3") testInstrumentation(project(":instrumentation:netty:netty-4.1:javaagent")) testLibrary("io.grpc:grpc-netty:$grpcVersion") - testLibrary("io.grpc:grpc-protobuf:$grpcVersion") + library("io.grpc:grpc-protobuf:$grpcVersion") testLibrary("io.grpc:grpc-services:$grpcVersion") testLibrary("io.grpc:grpc-stub:$grpcVersion") diff --git a/instrumentation/grpc-1.6/library/build.gradle.kts b/instrumentation/grpc-1.6/library/build.gradle.kts index c8db501eb27f..b07ea2aa9ea3 100644 --- a/instrumentation/grpc-1.6/library/build.gradle.kts +++ b/instrumentation/grpc-1.6/library/build.gradle.kts @@ -7,10 +7,9 @@ val grpcVersion = "1.6.0" dependencies { library("io.grpc:grpc-core:$grpcVersion") - library("com.google.protobuf:protobuf-java:3.25.3") testLibrary("io.grpc:grpc-netty:$grpcVersion") - testLibrary("io.grpc:grpc-protobuf:$grpcVersion") + library("io.grpc:grpc-protobuf:$grpcVersion") testLibrary("io.grpc:grpc-services:$grpcVersion") testLibrary("io.grpc:grpc-stub:$grpcVersion") From 69ee2bdf540ecbf8cc07a2343a14e4644f9ec059 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Thu, 18 Jul 2024 18:53:22 +0800 Subject: [PATCH 15/24] fix muzzle --- instrumentation/grpc-1.6/javaagent/build.gradle.kts | 1 + 1 file changed, 1 insertion(+) diff --git a/instrumentation/grpc-1.6/javaagent/build.gradle.kts b/instrumentation/grpc-1.6/javaagent/build.gradle.kts index d942aacf1100..282d3a49f638 100644 --- a/instrumentation/grpc-1.6/javaagent/build.gradle.kts +++ b/instrumentation/grpc-1.6/javaagent/build.gradle.kts @@ -8,6 +8,7 @@ muzzle { module.set("grpc-core") versions.set("[1.6.0,)") assertInverse.set(true) + extraDependency("io.grpc:grpc-protobuf:1.6.0") } } From a10ffca2c5e187edf60aaf5ff9dee0c61ad77b67 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Thu, 18 Jul 2024 21:09:22 +0800 Subject: [PATCH 16/24] fix muzzle --- instrumentation/grpc-1.6/javaagent/build.gradle.kts | 1 - 1 file changed, 1 deletion(-) diff --git a/instrumentation/grpc-1.6/javaagent/build.gradle.kts b/instrumentation/grpc-1.6/javaagent/build.gradle.kts index 282d3a49f638..d942aacf1100 100644 --- a/instrumentation/grpc-1.6/javaagent/build.gradle.kts +++ b/instrumentation/grpc-1.6/javaagent/build.gradle.kts @@ -8,7 +8,6 @@ muzzle { module.set("grpc-core") versions.set("[1.6.0,)") assertInverse.set(true) - extraDependency("io.grpc:grpc-protobuf:1.6.0") } } From e45c225fafe4b620ba8c51cc585a046b474840a8 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Thu, 18 Jul 2024 21:31:30 +0800 Subject: [PATCH 17/24] fix muzzle --- instrumentation/grpc-1.6/javaagent/build.gradle.kts | 1 + 1 file changed, 1 insertion(+) diff --git a/instrumentation/grpc-1.6/javaagent/build.gradle.kts b/instrumentation/grpc-1.6/javaagent/build.gradle.kts index d942aacf1100..282d3a49f638 100644 --- a/instrumentation/grpc-1.6/javaagent/build.gradle.kts +++ b/instrumentation/grpc-1.6/javaagent/build.gradle.kts @@ -8,6 +8,7 @@ muzzle { module.set("grpc-core") versions.set("[1.6.0,)") assertInverse.set(true) + extraDependency("io.grpc:grpc-protobuf:1.6.0") } } From bfe90879af0432be68c4eddca7be11a7256579b6 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Sat, 20 Jul 2024 22:12:33 +0800 Subject: [PATCH 18/24] fix muzzle --- instrumentation/grpc-1.6/javaagent/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/instrumentation/grpc-1.6/javaagent/build.gradle.kts b/instrumentation/grpc-1.6/javaagent/build.gradle.kts index 282d3a49f638..11cc03fdf78c 100644 --- a/instrumentation/grpc-1.6/javaagent/build.gradle.kts +++ b/instrumentation/grpc-1.6/javaagent/build.gradle.kts @@ -8,7 +8,7 @@ muzzle { module.set("grpc-core") versions.set("[1.6.0,)") assertInverse.set(true) - extraDependency("io.grpc:grpc-protobuf:1.6.0") + extraDependency("io.grpc:grpc-protobuf:1.5.0") } } From 43054adae25284a7c6b62f9beee7a215ac066a2e Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Mon, 22 Jul 2024 18:46:12 +0800 Subject: [PATCH 19/24] use static import asList --- .../api/incubator/semconv/rpc/RpcMetricsAdvice.java | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java index cae2b376ddd1..03f2a4513fac 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java @@ -5,6 +5,8 @@ package io.opentelemetry.instrumentation.api.incubator.semconv.rpc; +import static java.util.Arrays.asList; + import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.incubator.metrics.ExtendedDoubleHistogramBuilder; import io.opentelemetry.api.incubator.metrics.ExtendedLongHistogramBuilder; @@ -12,7 +14,6 @@ import io.opentelemetry.api.metrics.LongHistogramBuilder; import io.opentelemetry.semconv.NetworkAttributes; import io.opentelemetry.semconv.ServerAttributes; -import java.util.Arrays; final class RpcMetricsAdvice { @@ -28,7 +29,7 @@ static void applyClientDurationAdvice(DoubleHistogramBuilder builder) { // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-metrics.md ((ExtendedDoubleHistogramBuilder) builder) .setAttributesAdvice( - Arrays.asList( + asList( RpcCommonAttributesExtractor.RPC_SYSTEM, RpcCommonAttributesExtractor.RPC_SERVICE, RpcCommonAttributesExtractor.RPC_METHOD, @@ -47,7 +48,7 @@ static void applyServerDurationAdvice(DoubleHistogramBuilder builder) { // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-metrics.md ((ExtendedDoubleHistogramBuilder) builder) .setAttributesAdvice( - Arrays.asList( + asList( RpcCommonAttributesExtractor.RPC_SYSTEM, RpcCommonAttributesExtractor.RPC_SERVICE, RpcCommonAttributesExtractor.RPC_METHOD, @@ -66,7 +67,7 @@ static void applyClientRequestSizeAdvice(LongHistogramBuilder builder) { // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-metrics.md ((ExtendedLongHistogramBuilder) builder) .setAttributesAdvice( - Arrays.asList( + asList( RpcCommonAttributesExtractor.RPC_SYSTEM, RpcCommonAttributesExtractor.RPC_SERVICE, RpcCommonAttributesExtractor.RPC_METHOD, @@ -85,7 +86,7 @@ static void applyServerRequestSizeAdvice(LongHistogramBuilder builder) { // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-metrics.md ((ExtendedLongHistogramBuilder) builder) .setAttributesAdvice( - Arrays.asList( + asList( RpcCommonAttributesExtractor.RPC_SYSTEM, RpcCommonAttributesExtractor.RPC_SERVICE, RpcCommonAttributesExtractor.RPC_METHOD, From 1438a0a889b8b833bf7c09ead6feee82682926e4 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Wed, 24 Jul 2024 13:31:05 +0800 Subject: [PATCH 20/24] fix with cr --- .../semconv/rpc/RpcAttributesGetter.java | 16 ++--- .../semconv/rpc/RpcClientMetrics.java | 4 +- .../rpc/RpcCommonAttributesExtractor.java | 31 +++++----- .../semconv/rpc/RpcMetricsAdvice.java | 59 +++++-------------- .../semconv/rpc/RpcServerMetrics.java | 4 +- .../semconv/rpc/RpcClientMetricsTest.java | 5 +- .../semconv/rpc/RpcServerMetricsTest.java | 5 +- .../grpc-1.6/library/build.gradle.kts | 2 +- .../grpc/v1_6/BodySizeUtil.java | 6 +- .../grpc/v1_6/GrpcRequest.java | 39 ++++-------- .../grpc/v1_6/GrpcRpcAttributesGetter.java | 18 ++---- .../grpc/v1_6/TracingClientInterceptor.java | 4 +- .../grpc/v1_6/TracingServerInterceptor.java | 4 +- .../grpc/v1_6/AbstractGrpcTest.java | 4 +- 14 files changed, 67 insertions(+), 134 deletions(-) diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcAttributesGetter.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcAttributesGetter.java index a15db2015418..6b0ae2669cc9 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcAttributesGetter.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcAttributesGetter.java @@ -25,19 +25,11 @@ public interface RpcAttributesGetter { @Nullable String getMethod(REQUEST request); - default int getClientRequestSize(REQUEST request) { - return 0; + default Long getRequestSize(REQUEST request) { + return null; } - default int getClientResponseSize(REQUEST request) { - return 0; - } - - default int getServerRequestSize(REQUEST request) { - return 0; - } - - default int getServerResponseSize(REQUEST request) { - return 0; + default Long getResponseSize(REQUEST request) { + return null; } } diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java index 959dc8a3de6b..d7abe934adc5 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java @@ -100,13 +100,13 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { Long rpcClientRequestBodySize = RpcMessageBodySizeUtil.getRpcClientRequestBodySize(endAttributes, state.startAttributes()); - if (rpcClientRequestBodySize != null && rpcClientRequestBodySize > 0) { + if (rpcClientRequestBodySize != null) { clientRequestSize.record(rpcClientRequestBodySize, attributes, context); } Long rpcClientResponseBodySize = RpcMessageBodySizeUtil.getRpcClientResponseBodySize(endAttributes, state.startAttributes()); - if (rpcClientResponseBodySize != null && rpcClientResponseBodySize > 0) { + if (rpcClientResponseBodySize != null) { clientResponseSize.record(rpcClientResponseBodySize, attributes, context); } } diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java index 9d61e7c24d32..3c871f59e920 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java @@ -49,23 +49,24 @@ public final void onEnd( REQUEST request, @Nullable RESPONSE response, @Nullable Throwable error) { - int clientRequestSize = getter.getClientRequestSize(request); - if (clientRequestSize > 0) { - internalSet(attributes, RPC_CLIENT_REQUEST_BODY_SIZE, (long) clientRequestSize); - } - int clientResponseSize = getter.getClientResponseSize(request); - if (clientResponseSize > 0) { - internalSet(attributes, RPC_CLIENT_RESPONSE_BODY_SIZE, (long) clientResponseSize); - } - - int serverRequestSize = getter.getServerRequestSize(request); - if (serverRequestSize > 0) { - internalSet(attributes, RPC_SERVER_REQUEST_BODY_SIZE, (long) serverRequestSize); + Long requestSize = getter.getRequestSize(request); + Long responseSize = getter.getResponseSize(request); + if (this instanceof RpcClientAttributesExtractor) { + if (requestSize != null) { + internalSet(attributes, RPC_CLIENT_REQUEST_BODY_SIZE, requestSize); + } + if (responseSize != null) { + internalSet(attributes, RPC_CLIENT_RESPONSE_BODY_SIZE, responseSize); + } } - int serverResponseSize = getter.getServerResponseSize(request); - if (serverResponseSize > 0) { - internalSet(attributes, RPC_SERVER_RESPONSE_BODY_SIZE, (long) serverResponseSize); + if (this instanceof RpcServerAttributesExtractor) { + if (requestSize != null) { + internalSet(attributes, RPC_SERVER_REQUEST_BODY_SIZE, requestSize); + } + if (responseSize != null) { + internalSet(attributes, RPC_SERVER_RESPONSE_BODY_SIZE, responseSize); + } } } } diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java index 03f2a4513fac..af317d876d62 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMetricsAdvice.java @@ -14,12 +14,23 @@ import io.opentelemetry.api.metrics.LongHistogramBuilder; import io.opentelemetry.semconv.NetworkAttributes; import io.opentelemetry.semconv.ServerAttributes; +import java.util.List; final class RpcMetricsAdvice { // copied from RpcIncubatingAttributes private static final AttributeKey RPC_GRPC_STATUS_CODE = AttributeKey.longKey("rpc.grpc.status_code"); + private static final List> RPC_METRICS_ATTRIBUTE_KEYS = + asList( + RpcCommonAttributesExtractor.RPC_SYSTEM, + RpcCommonAttributesExtractor.RPC_SERVICE, + RpcCommonAttributesExtractor.RPC_METHOD, + RPC_GRPC_STATUS_CODE, + NetworkAttributes.NETWORK_TYPE, + NetworkAttributes.NETWORK_TRANSPORT, + ServerAttributes.SERVER_ADDRESS, + ServerAttributes.SERVER_PORT); static void applyClientDurationAdvice(DoubleHistogramBuilder builder) { if (!(builder instanceof ExtendedDoubleHistogramBuilder)) { @@ -27,17 +38,7 @@ static void applyClientDurationAdvice(DoubleHistogramBuilder builder) { } // the list of recommended metrics attributes is from // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-metrics.md - ((ExtendedDoubleHistogramBuilder) builder) - .setAttributesAdvice( - asList( - RpcCommonAttributesExtractor.RPC_SYSTEM, - RpcCommonAttributesExtractor.RPC_SERVICE, - RpcCommonAttributesExtractor.RPC_METHOD, - RPC_GRPC_STATUS_CODE, - NetworkAttributes.NETWORK_TYPE, - NetworkAttributes.NETWORK_TRANSPORT, - ServerAttributes.SERVER_ADDRESS, - ServerAttributes.SERVER_PORT)); + ((ExtendedDoubleHistogramBuilder) builder).setAttributesAdvice(RPC_METRICS_ATTRIBUTE_KEYS); } static void applyServerDurationAdvice(DoubleHistogramBuilder builder) { @@ -46,17 +47,7 @@ static void applyServerDurationAdvice(DoubleHistogramBuilder builder) { } // the list of recommended metrics attributes is from // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-metrics.md - ((ExtendedDoubleHistogramBuilder) builder) - .setAttributesAdvice( - asList( - RpcCommonAttributesExtractor.RPC_SYSTEM, - RpcCommonAttributesExtractor.RPC_SERVICE, - RpcCommonAttributesExtractor.RPC_METHOD, - RPC_GRPC_STATUS_CODE, - NetworkAttributes.NETWORK_TYPE, - NetworkAttributes.NETWORK_TRANSPORT, - ServerAttributes.SERVER_ADDRESS, - ServerAttributes.SERVER_PORT)); + ((ExtendedDoubleHistogramBuilder) builder).setAttributesAdvice(RPC_METRICS_ATTRIBUTE_KEYS); } static void applyClientRequestSizeAdvice(LongHistogramBuilder builder) { @@ -65,17 +56,7 @@ static void applyClientRequestSizeAdvice(LongHistogramBuilder builder) { } // the list of recommended metrics attributes is from // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-metrics.md - ((ExtendedLongHistogramBuilder) builder) - .setAttributesAdvice( - asList( - RpcCommonAttributesExtractor.RPC_SYSTEM, - RpcCommonAttributesExtractor.RPC_SERVICE, - RpcCommonAttributesExtractor.RPC_METHOD, - RPC_GRPC_STATUS_CODE, - NetworkAttributes.NETWORK_TYPE, - NetworkAttributes.NETWORK_TRANSPORT, - ServerAttributes.SERVER_ADDRESS, - ServerAttributes.SERVER_PORT)); + ((ExtendedLongHistogramBuilder) builder).setAttributesAdvice(RPC_METRICS_ATTRIBUTE_KEYS); } static void applyServerRequestSizeAdvice(LongHistogramBuilder builder) { @@ -84,17 +65,7 @@ static void applyServerRequestSizeAdvice(LongHistogramBuilder builder) { } // the list of recommended metrics attributes is from // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/rpc/rpc-metrics.md - ((ExtendedLongHistogramBuilder) builder) - .setAttributesAdvice( - asList( - RpcCommonAttributesExtractor.RPC_SYSTEM, - RpcCommonAttributesExtractor.RPC_SERVICE, - RpcCommonAttributesExtractor.RPC_METHOD, - RPC_GRPC_STATUS_CODE, - NetworkAttributes.NETWORK_TYPE, - NetworkAttributes.NETWORK_TRANSPORT, - ServerAttributes.SERVER_ADDRESS, - ServerAttributes.SERVER_PORT)); + ((ExtendedLongHistogramBuilder) builder).setAttributesAdvice(RPC_METRICS_ATTRIBUTE_KEYS); } private RpcMetricsAdvice() {} diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java index 572376b3b23d..05fdde100d37 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java @@ -100,13 +100,13 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { Long rpcServerRequestBodySize = RpcMessageBodySizeUtil.getRpcServerRequestBodySize(endAttributes, state.startAttributes()); - if (rpcServerRequestBodySize != null && rpcServerRequestBodySize > 0) { + if (rpcServerRequestBodySize != null) { serverRequestSize.record(rpcServerRequestBodySize, attributes, context); } Long rpcServerResponseBodySize = RpcMessageBodySizeUtil.getRpcServerResponseBodySize(endAttributes, state.startAttributes()); - if (rpcServerResponseBodySize != null && rpcServerResponseBodySize > 0) { + if (rpcServerResponseBodySize != null) { serverResponseSize.record(rpcServerResponseBodySize, attributes, context); } } diff --git a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java index 6506664e69a6..1613a7a7dca4 100644 --- a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java +++ b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java @@ -16,7 +16,6 @@ import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; import io.opentelemetry.sdk.metrics.SdkMeterProvider; -import io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; import io.opentelemetry.semconv.NetworkAttributes; import io.opentelemetry.semconv.ServerAttributes; @@ -80,7 +79,7 @@ void collectsMetrics() { assertThat(metricReader.collectAllMetrics()) .satisfiesExactlyInAnyOrder( metric -> - OpenTelemetryAssertions.assertThat(metric) + assertThat(metric) .hasName("rpc.client.response.size") .hasUnit("By") .hasDescription("Measures the size of RPC response messages (uncompressed).") @@ -108,7 +107,7 @@ void collectsMetrics() { .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") .hasSpanId("090a0b0c0d0e0f00")))), metric -> - OpenTelemetryAssertions.assertThat(metric) + assertThat(metric) .hasName("rpc.client.request.size") .hasUnit("By") .hasDescription("Measures the size of RPC request messages (uncompressed).") diff --git a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java index ad598c6f0d26..cd7f787e467c 100644 --- a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java +++ b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java @@ -16,7 +16,6 @@ import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.OperationListener; import io.opentelemetry.sdk.metrics.SdkMeterProvider; -import io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; import io.opentelemetry.semconv.NetworkAttributes; import io.opentelemetry.semconv.ServerAttributes; @@ -108,7 +107,7 @@ void collectsMetrics() { .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") .hasSpanId("090a0b0c0d0e0f00")))), metric -> - OpenTelemetryAssertions.assertThat(metric) + assertThat(metric) .hasName("rpc.server.response.size") .hasUnit("By") .hasDescription("Measures the size of RPC response messages (uncompressed).") @@ -135,7 +134,7 @@ void collectsMetrics() { .hasTraceId("ff01020304050600ff0a0b0c0d0e0f00") .hasSpanId("090a0b0c0d0e0f00")))), metric -> - OpenTelemetryAssertions.assertThat(metric) + assertThat(metric) .hasName("rpc.server.request.size") .hasUnit("By") .hasDescription("Measures the size of RPC request messages (uncompressed).") diff --git a/instrumentation/grpc-1.6/library/build.gradle.kts b/instrumentation/grpc-1.6/library/build.gradle.kts index b07ea2aa9ea3..f35591d4f0b3 100644 --- a/instrumentation/grpc-1.6/library/build.gradle.kts +++ b/instrumentation/grpc-1.6/library/build.gradle.kts @@ -7,9 +7,9 @@ val grpcVersion = "1.6.0" dependencies { library("io.grpc:grpc-core:$grpcVersion") + library("io.grpc:grpc-protobuf:$grpcVersion") testLibrary("io.grpc:grpc-netty:$grpcVersion") - library("io.grpc:grpc-protobuf:$grpcVersion") testLibrary("io.grpc:grpc-services:$grpcVersion") testLibrary("io.grpc:grpc-stub:$grpcVersion") diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/BodySizeUtil.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/BodySizeUtil.java index 536a92888330..c878882386e9 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/BodySizeUtil.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/BodySizeUtil.java @@ -9,12 +9,12 @@ final class BodySizeUtil { - static int getBodySize(T message) { + static Long getBodySize(T message) { if (message instanceof MessageLite) { - return ((MessageLite) message).getSerializedSize(); + return (long) ((MessageLite) message).getSerializedSize(); } else { // Message is not a protobuf message - return 0; + return null; } } diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java index 3faa4cd50c36..926799191bb2 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRequest.java @@ -20,11 +20,8 @@ public final class GrpcRequest { private volatile int logicalPort = -1; @Nullable private volatile SocketAddress peerSocketAddress; - private int clientRequestSize; - private int clientResponseSize; - - private int serverRequestSize; - private int serverResponseSize; + private Long requestSize; + private Long responseSize; GrpcRequest( MethodDescriptor method, @@ -85,35 +82,19 @@ void setPeerSocketAddress(SocketAddress peerSocketAddress) { this.peerSocketAddress = peerSocketAddress; } - public int getClientRequestSize() { - return clientRequestSize; - } - - void setClientRequestSize(int clientRequestSize) { - this.clientRequestSize = clientRequestSize; - } - - public int getClientResponseSize() { - return clientResponseSize; - } - - void setClientResponseSize(int clientResponseSize) { - this.clientResponseSize = clientResponseSize; - } - - public int getServerRequestSize() { - return serverRequestSize; + public Long getRequestSize() { + return requestSize; } - public void setServerRequestSize(int serverRequestSize) { - this.serverRequestSize = serverRequestSize; + public void setRequestSize(Long requestSize) { + this.requestSize = requestSize; } - public int getServerResponseSize() { - return serverResponseSize; + public Long getResponseSize() { + return responseSize; } - public void setServerResponseSize(int serverResponseSize) { - this.serverResponseSize = serverResponseSize; + public void setResponseSize(Long responseSize) { + this.responseSize = responseSize; } } diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java index f9b490e65f22..d114b0090cf2 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/GrpcRpcAttributesGetter.java @@ -44,23 +44,13 @@ public String getMethod(GrpcRequest request) { } @Override - public int getClientRequestSize(GrpcRequest request) { - return request.getClientRequestSize(); + public Long getRequestSize(GrpcRequest request) { + return request.getRequestSize(); } @Override - public int getClientResponseSize(GrpcRequest request) { - return request.getClientResponseSize(); - } - - @Override - public int getServerRequestSize(GrpcRequest request) { - return request.getServerRequestSize(); - } - - @Override - public int getServerResponseSize(GrpcRequest request) { - return request.getServerResponseSize(); + public Long getResponseSize(GrpcRequest request) { + return request.getResponseSize(); } List metadataValue(GrpcRequest request, String key) { diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingClientInterceptor.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingClientInterceptor.java index 4b3a888e5799..b2a0deb22c62 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingClientInterceptor.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingClientInterceptor.java @@ -126,7 +126,7 @@ public void start(Listener responseListener, Metadata headers) { @Override public void sendMessage(REQUEST message) { - request.setClientRequestSize(BodySizeUtil.getBodySize(message)); + request.setRequestSize(BodySizeUtil.getBodySize(message)); try (Scope ignored = context.makeCurrent()) { super.sendMessage(message); } catch (Throwable e) { @@ -160,7 +160,7 @@ final class TracingClientCallListener @Override public void onMessage(RESPONSE message) { - request.setClientResponseSize(BodySizeUtil.getBodySize(message)); + request.setResponseSize(BodySizeUtil.getBodySize(message)); long messageId = RECEIVED_MESSAGE_ID_UPDATER.incrementAndGet(TracingClientCall.this); if (emitMessageEvents) { Attributes attributes = Attributes.of(MESSAGE_TYPE, RECEIVED, MESSAGE_ID, messageId); diff --git a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingServerInterceptor.java b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingServerInterceptor.java index a5eafd0b1ada..688099084146 100644 --- a/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingServerInterceptor.java +++ b/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingServerInterceptor.java @@ -119,7 +119,7 @@ TracingServerCallListener start(Metadata headers, ServerCallHandler { assertThat(events).hasSize(3); @@ -1171,7 +1171,7 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_SERVER_REQUEST_BODY_SIZE, 0), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> From 063160f9b7f3ee75fe3e9d38f5b88123e8500835 Mon Sep 17 00:00:00 2001 From: crossoverJie Date: Wed, 31 Jul 2024 16:38:05 +0800 Subject: [PATCH 21/24] remove client&server prefix. --- .../semconv/rpc/RpcClientMetrics.java | 4 +- .../rpc/RpcCommonAttributesExtractor.java | 20 +++--- .../semconv/rpc/RpcMessageBodySizeUtil.java | 18 ++--- .../semconv/rpc/RpcServerMetrics.java | 4 +- .../semconv/rpc/RpcClientMetricsTest.java | 4 +- .../semconv/rpc/RpcServerMetricsTest.java | 4 +- .../armeria/grpc/v1_14/ArmeriaGrpcTest.java | 20 +++--- .../grpc/v1_6/AbstractGrpcStreamingTest.java | 20 +++--- .../grpc/v1_6/AbstractGrpcTest.java | 72 +++++++++---------- 9 files changed, 70 insertions(+), 96 deletions(-) diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java index d7abe934adc5..b3b6c211677d 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetrics.java @@ -99,13 +99,13 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { (endNanos - state.startTimeNanos()) / NANOS_PER_MS, attributes, context); Long rpcClientRequestBodySize = - RpcMessageBodySizeUtil.getRpcClientRequestBodySize(endAttributes, state.startAttributes()); + RpcMessageBodySizeUtil.getRpcRequestBodySize(endAttributes, state.startAttributes()); if (rpcClientRequestBodySize != null) { clientRequestSize.record(rpcClientRequestBodySize, attributes, context); } Long rpcClientResponseBodySize = - RpcMessageBodySizeUtil.getRpcClientResponseBodySize(endAttributes, state.startAttributes()); + RpcMessageBodySizeUtil.getRpcResponseBodySize(endAttributes, state.startAttributes()); if (rpcClientResponseBodySize != null) { clientResponseSize.record(rpcClientResponseBodySize, attributes, context); } diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java index 3c871f59e920..13d4c9af75e6 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcCommonAttributesExtractor.java @@ -20,14 +20,10 @@ abstract class RpcCommonAttributesExtractor static final AttributeKey RPC_METHOD = AttributeKey.stringKey("rpc.method"); static final AttributeKey RPC_SERVICE = AttributeKey.stringKey("rpc.service"); static final AttributeKey RPC_SYSTEM = AttributeKey.stringKey("rpc.system"); - static final AttributeKey RPC_CLIENT_REQUEST_BODY_SIZE = - AttributeKey.longKey("rpc.client.request.body.size"); - static final AttributeKey RPC_CLIENT_RESPONSE_BODY_SIZE = - AttributeKey.longKey("rpc.client.response.body.size"); - static final AttributeKey RPC_SERVER_REQUEST_BODY_SIZE = - AttributeKey.longKey("rpc.server.request.body.size"); - static final AttributeKey RPC_SERVER_RESPONSE_BODY_SIZE = - AttributeKey.longKey("rpc.server.response.body.size"); + static final AttributeKey RPC_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.request.body.size"); + static final AttributeKey RPC_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.response.body.size"); private final RpcAttributesGetter getter; @@ -53,19 +49,19 @@ public final void onEnd( Long responseSize = getter.getResponseSize(request); if (this instanceof RpcClientAttributesExtractor) { if (requestSize != null) { - internalSet(attributes, RPC_CLIENT_REQUEST_BODY_SIZE, requestSize); + internalSet(attributes, RPC_REQUEST_BODY_SIZE, requestSize); } if (responseSize != null) { - internalSet(attributes, RPC_CLIENT_RESPONSE_BODY_SIZE, responseSize); + internalSet(attributes, RPC_RESPONSE_BODY_SIZE, responseSize); } } if (this instanceof RpcServerAttributesExtractor) { if (requestSize != null) { - internalSet(attributes, RPC_SERVER_REQUEST_BODY_SIZE, requestSize); + internalSet(attributes, RPC_REQUEST_BODY_SIZE, requestSize); } if (responseSize != null) { - internalSet(attributes, RPC_SERVER_RESPONSE_BODY_SIZE, responseSize); + internalSet(attributes, RPC_RESPONSE_BODY_SIZE, responseSize); } } } diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java index 2baba8a67678..6ebc66e26e75 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcMessageBodySizeUtil.java @@ -12,23 +12,13 @@ final class RpcMessageBodySizeUtil { @Nullable - static Long getRpcClientRequestBodySize(Attributes... attributesList) { - return getAttribute(RpcCommonAttributesExtractor.RPC_CLIENT_REQUEST_BODY_SIZE, attributesList); + static Long getRpcRequestBodySize(Attributes... attributesList) { + return getAttribute(RpcCommonAttributesExtractor.RPC_REQUEST_BODY_SIZE, attributesList); } @Nullable - static Long getRpcClientResponseBodySize(Attributes... attributesList) { - return getAttribute(RpcCommonAttributesExtractor.RPC_CLIENT_RESPONSE_BODY_SIZE, attributesList); - } - - @Nullable - static Long getRpcServerRequestBodySize(Attributes... attributesList) { - return getAttribute(RpcCommonAttributesExtractor.RPC_SERVER_REQUEST_BODY_SIZE, attributesList); - } - - @Nullable - static Long getRpcServerResponseBodySize(Attributes... attributesList) { - return getAttribute(RpcCommonAttributesExtractor.RPC_SERVER_RESPONSE_BODY_SIZE, attributesList); + static Long getRpcResponseBodySize(Attributes... attributesList) { + return getAttribute(RpcCommonAttributesExtractor.RPC_RESPONSE_BODY_SIZE, attributesList); } @Nullable diff --git a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java index 05fdde100d37..0755e315dc85 100644 --- a/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java +++ b/instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetrics.java @@ -99,13 +99,13 @@ public void onEnd(Context context, Attributes endAttributes, long endNanos) { (endNanos - state.startTimeNanos()) / NANOS_PER_MS, attributes, context); Long rpcServerRequestBodySize = - RpcMessageBodySizeUtil.getRpcServerRequestBodySize(endAttributes, state.startAttributes()); + RpcMessageBodySizeUtil.getRpcRequestBodySize(endAttributes, state.startAttributes()); if (rpcServerRequestBodySize != null) { serverRequestSize.record(rpcServerRequestBodySize, attributes, context); } Long rpcServerResponseBodySize = - RpcMessageBodySizeUtil.getRpcServerResponseBodySize(endAttributes, state.startAttributes()); + RpcMessageBodySizeUtil.getRpcResponseBodySize(endAttributes, state.startAttributes()); if (rpcServerResponseBodySize != null) { serverResponseSize.record(rpcServerResponseBodySize, attributes, context); } diff --git a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java index 1613a7a7dca4..a75c9b55e7aa 100644 --- a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java +++ b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcClientMetricsTest.java @@ -46,8 +46,8 @@ void collectsMetrics() { .put(ServerAttributes.SERVER_PORT, 8080) .put(NetworkAttributes.NETWORK_TRANSPORT, "tcp") .put(NetworkAttributes.NETWORK_TYPE, "ipv4") - .put(RpcCommonAttributesExtractor.RPC_CLIENT_REQUEST_BODY_SIZE, 10) - .put(RpcCommonAttributesExtractor.RPC_CLIENT_RESPONSE_BODY_SIZE, 20) + .put(RpcCommonAttributesExtractor.RPC_REQUEST_BODY_SIZE, 10) + .put(RpcCommonAttributesExtractor.RPC_RESPONSE_BODY_SIZE, 20) .build(); Attributes responseAttributes2 = diff --git a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java index cd7f787e467c..3a4a322b5f2e 100644 --- a/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java +++ b/instrumentation-api-incubator/src/test/java/io/opentelemetry/instrumentation/api/incubator/semconv/rpc/RpcServerMetricsTest.java @@ -47,8 +47,8 @@ void collectsMetrics() { .put(NetworkAttributes.NETWORK_LOCAL_ADDRESS, "127.0.0.1") .put(NetworkAttributes.NETWORK_TRANSPORT, "tcp") .put(NetworkAttributes.NETWORK_TYPE, "ipv4") - .put(RpcCommonAttributesExtractor.RPC_SERVER_REQUEST_BODY_SIZE, 10) - .put(RpcCommonAttributesExtractor.RPC_SERVER_RESPONSE_BODY_SIZE, 20) + .put(RpcCommonAttributesExtractor.RPC_REQUEST_BODY_SIZE, 10) + .put(RpcCommonAttributesExtractor.RPC_RESPONSE_BODY_SIZE, 20) .build(); Attributes responseAttributes2 = diff --git a/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java b/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java index 43f0f4af81f4..418a330b1c2d 100644 --- a/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java +++ b/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java @@ -34,14 +34,10 @@ class ArmeriaGrpcTest { @RegisterExtension static final AgentInstrumentationExtension testing = AgentInstrumentationExtension.create(); - private static final AttributeKey RPC_CLIENT_REQUEST_BODY_SIZE = - AttributeKey.longKey("rpc.client.request.body.size"); - private static final AttributeKey RPC_CLIENT_RESPONSE_BODY_SIZE = - AttributeKey.longKey("rpc.client.response.body.size"); - private static final AttributeKey RPC_SERVER_REQUEST_BODY_SIZE = - AttributeKey.longKey("rpc.server.request.body.size"); - private static final AttributeKey RPC_SERVER_RESPONSE_BODY_SIZE = - AttributeKey.longKey("rpc.server.response.body.size"); + private static final AttributeKey RPC_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.request.body.size"); + private static final AttributeKey RPC_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.response.body.size"); @RegisterExtension static final ServerExtension server = @@ -95,8 +91,8 @@ void grpcInstrumentation() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "127.0.0.1"), equalTo(SERVER_PORT, (long) server.httpPort())) - equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), - equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize)) + equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize)) .hasEventsSatisfyingExactly( event -> event @@ -122,8 +118,8 @@ void grpcInstrumentation() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "127.0.0.1"), equalTo(SERVER_PORT, server.httpPort())) - equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), - equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize)) + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize)) .hasEventsSatisfyingExactly( event -> event diff --git a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java index 961b16ec0606..a18697cee49f 100644 --- a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java +++ b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java @@ -53,14 +53,10 @@ public abstract class AbstractGrpcStreamingTest { - private static final AttributeKey RPC_CLIENT_REQUEST_BODY_SIZE = - AttributeKey.longKey("rpc.client.request.body.size"); - private static final AttributeKey RPC_CLIENT_RESPONSE_BODY_SIZE = - AttributeKey.longKey("rpc.client.response.body.size"); - private static final AttributeKey RPC_SERVER_REQUEST_BODY_SIZE = - AttributeKey.longKey("rpc.server.request.body.size"); - private static final AttributeKey RPC_SERVER_RESPONSE_BODY_SIZE = - AttributeKey.longKey("rpc.server.response.body.size"); + private static final AttributeKey RPC_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.request.body.size"); + private static final AttributeKey RPC_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.response.body.size"); protected abstract ServerBuilder configureServer(ServerBuilder server); @@ -242,8 +238,8 @@ public void onCompleted() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, requestSerializedSize), - equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), .satisfies( spanData -> assertThat(spanData.getEvents()) @@ -261,8 +257,8 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_SERVER_REQUEST_BODY_SIZE, requestSerializedSize), - equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .satisfies( spanData -> diff --git a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java index 23ff45b65e98..681e7eaa148c 100644 --- a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java +++ b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java @@ -85,14 +85,10 @@ public abstract class AbstractGrpcTest { protected static final String SERVER_REQUEST_METADATA_KEY = "some-server-key"; - private static final AttributeKey RPC_CLIENT_REQUEST_BODY_SIZE = - AttributeKey.longKey("rpc.client.request.body.size"); - private static final AttributeKey RPC_CLIENT_RESPONSE_BODY_SIZE = - AttributeKey.longKey("rpc.client.response.body.size"); - private static final AttributeKey RPC_SERVER_REQUEST_BODY_SIZE = - AttributeKey.longKey("rpc.server.request.body.size"); - private static final AttributeKey RPC_SERVER_RESPONSE_BODY_SIZE = - AttributeKey.longKey("rpc.server.response.body.size"); + private static final AttributeKey RPC_REQUEST_BODY_SIZE = + AttributeKey.longKey("rpc.request.body.size"); + private static final AttributeKey RPC_RESPONSE_BODY_SIZE = + AttributeKey.longKey("rpc.response.body.size"); protected abstract ServerBuilder configureServer(ServerBuilder server); @@ -157,9 +153,9 @@ public void sayHello( equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), equalTo( - RPC_CLIENT_REQUEST_BODY_SIZE, + RPC_REQUEST_BODY_SIZE, responseSerializedSize - prefix.length()), .hasEventsSatisfyingExactly( event -> @@ -192,9 +188,9 @@ public void sayHello( equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) equalTo( - RPC_SERVER_RESPONSE_BODY_SIZE, + RPC_RESPONSE_BODY_SIZE, responseSerializedSize - prefix.length()), - equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -322,8 +318,8 @@ public void sayHello( equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), - equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -353,8 +349,8 @@ public void sayHello( equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), - equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -495,8 +491,8 @@ public void onCompleted() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), - equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -526,8 +522,8 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), - equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -640,7 +636,7 @@ public void sayHello( equalTo(RPC_GRPC_STATUS_CODE, (long) status.getCode().value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -663,7 +659,7 @@ public void sayHello( equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfying( events -> { @@ -781,7 +777,7 @@ public void sayHello( (long) Status.UNKNOWN.getCode().value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -804,7 +800,7 @@ public void sayHello( equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfying( events -> { @@ -1017,8 +1013,8 @@ public void onCompleted() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), - equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -1048,8 +1044,8 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), - equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -1141,7 +1137,7 @@ public void onCompleted() { RPC_GRPC_STATUS_CODE, (long) Status.Code.CANCELLED.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, 0), + equalTo(RPC_RESPONSE_BODY_SIZE, 0), .hasEventsSatisfying( events -> { assertThat(events).hasSize(3); @@ -1171,7 +1167,7 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_SERVER_REQUEST_BODY_SIZE, 0), + equalTo(RPC_REQUEST_BODY_SIZE, 0), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -1261,8 +1257,8 @@ public void onCompleted() { equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), - equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize))) + equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize))) .hasEventsSatisfyingExactly( event -> event @@ -1293,8 +1289,8 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), - equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -1366,8 +1362,8 @@ public void sayHello( equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_CLIENT_RESPONSE_BODY_SIZE, responseSerializedSize), - equalTo(RPC_CLIENT_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -1397,8 +1393,8 @@ public void sayHello( equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_SERVER_REQUEST_BODY_SIZE, responseSerializedSize), - equalTo(RPC_SERVER_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> From d16cccf08c46a3b1f2dd90990251e5dbdab2861f Mon Sep 17 00:00:00 2001 From: Alex Sweet Date: Sun, 27 Jul 2025 22:43:07 -0700 Subject: [PATCH 22/24] fix tests --- .../grpc/v1_6/AbstractGrpcStreamingTest.java | 8 +-- .../grpc/v1_6/AbstractGrpcTest.java | 70 ++++++++++--------- 2 files changed, 42 insertions(+), 36 deletions(-) diff --git a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java index a18697cee49f..73d0405a1e1a 100644 --- a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java +++ b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcStreamingTest.java @@ -236,10 +236,10 @@ public void onCompleted() { equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "Conversation"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), - equalTo(SERVER_ADDRESS, "localhost"), - equalTo(SERVER_PORT, (long) server.getPort()))) equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(SERVER_ADDRESS, "localhost"), + equalTo(SERVER_PORT, (long) server.getPort()))) .satisfies( spanData -> assertThat(spanData.getEvents()) @@ -253,12 +253,12 @@ public void onCompleted() { equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "Conversation"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), - equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .satisfies( spanData -> diff --git a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java index 681e7eaa148c..9a9075f9a067 100644 --- a/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java +++ b/instrumentation/grpc-1.6/testing/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/AbstractGrpcTest.java @@ -151,12 +151,12 @@ public void sayHello( equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), - equalTo(SERVER_ADDRESS, "localhost"), - equalTo(SERVER_PORT, (long) server.getPort()))) equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), equalTo( RPC_REQUEST_BODY_SIZE, responseSerializedSize - prefix.length()), + equalTo(SERVER_ADDRESS, "localhost"), + equalTo(SERVER_PORT, (long) server.getPort()))) .hasEventsSatisfyingExactly( event -> event @@ -182,15 +182,15 @@ public void sayHello( equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), + equalTo( + RPC_RESPONSE_BODY_SIZE, + responseSerializedSize - prefix.length()), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) - equalTo( - RPC_RESPONSE_BODY_SIZE, - responseSerializedSize - prefix.length()), - equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -316,10 +316,10 @@ public void sayHello( equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), - equalTo(SERVER_ADDRESS, "localhost"), - equalTo(SERVER_PORT, (long) server.getPort()))) equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(SERVER_ADDRESS, "localhost"), + equalTo(SERVER_PORT, (long) server.getPort()))) .hasEventsSatisfyingExactly( event -> event @@ -345,12 +345,12 @@ public void sayHello( equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), - equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -489,10 +489,10 @@ public void onCompleted() { equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), - equalTo(SERVER_ADDRESS, "localhost"), - equalTo(SERVER_PORT, (long) server.getPort()))) equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(SERVER_ADDRESS, "localhost"), + equalTo(SERVER_PORT, (long) server.getPort()))) .hasEventsSatisfyingExactly( event -> event @@ -518,12 +518,12 @@ public void onCompleted() { equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), - equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -634,9 +634,9 @@ public void sayHello( equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) status.getCode().value()), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -655,11 +655,11 @@ public void sayHello( equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) status.getCode().value()), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfying( events -> { @@ -775,9 +775,9 @@ public void sayHello( equalTo( RPC_GRPC_STATUS_CODE, (long) Status.UNKNOWN.getCode().value()), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), .hasEventsSatisfyingExactly( event -> event @@ -796,11 +796,11 @@ public void sayHello( equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.UNKNOWN.value()), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfying( events -> { @@ -1011,10 +1011,10 @@ public void onCompleted() { equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), - equalTo(SERVER_ADDRESS, "localhost"), - equalTo(SERVER_PORT, (long) server.getPort()))) equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(SERVER_ADDRESS, "localhost"), + equalTo(SERVER_PORT, (long) server.getPort()))) .hasEventsSatisfyingExactly( event -> event @@ -1040,12 +1040,12 @@ public void onCompleted() { equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), - equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -1085,6 +1085,7 @@ public void sayMultipleHello( GreeterGrpc.GreeterStub client = GreeterGrpc.newStub(channel); IllegalStateException thrown = new IllegalStateException("illegal"); + AtomicReference response = new AtomicReference<>(); AtomicReference error = new AtomicReference<>(); CountDownLatch latch = new CountDownLatch(1); Helloworld.Request request = Helloworld.Request.newBuilder().setName("test").build(); @@ -1097,6 +1098,7 @@ public void sayMultipleHello( new StreamObserver() { @Override public void onNext(Helloworld.Response r) { + response.set(r); throw thrown; } @@ -1117,6 +1119,8 @@ public void onCompleted() { assertThat(error.get()).isNotNull(); int requestSerializedSize = request.getSerializedSize(); + Helloworld.Response res = response.get(); + int responseSerializedSize = res.getSerializedSize(); testing() .waitAndAssertTraces( @@ -1135,9 +1139,10 @@ public void onCompleted() { equalTo(RPC_METHOD, "SayMultipleHello"), equalTo( RPC_GRPC_STATUS_CODE, (long) Status.Code.CANCELLED.value()), + equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_RESPONSE_BODY_SIZE, 0), .hasEventsSatisfying( events -> { assertThat(events).hasSize(3); @@ -1167,7 +1172,8 @@ public void onCompleted() { equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_REQUEST_BODY_SIZE, 0), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -1255,10 +1261,10 @@ public void onCompleted() { RPC_SERVICE, "grpc.reflection.v1alpha.ServerReflection"), equalTo(RPC_METHOD, "ServerReflectionInfo"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), + equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, (long) server.getPort()))) - equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), - equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize))) .hasEventsSatisfyingExactly( event -> event @@ -1285,12 +1291,12 @@ public void onCompleted() { equalTo(RPC_SERVICE, "grpc.reflection.v1alpha.ServerReflection"), equalTo(RPC_METHOD, "ServerReflectionInfo"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), - equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> @@ -1360,10 +1366,10 @@ public void sayHello( equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), - equalTo(SERVER_ADDRESS, "localhost"), - equalTo(SERVER_PORT, (long) server.getPort()))) equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), + equalTo(SERVER_ADDRESS, "localhost"), + equalTo(SERVER_PORT, (long) server.getPort()))) .hasEventsSatisfyingExactly( event -> event @@ -1389,12 +1395,12 @@ public void sayHello( equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "localhost"), equalTo(SERVER_PORT, server.getPort()), equalTo(NETWORK_TYPE, "ipv4"), equalTo(NETWORK_PEER_ADDRESS, "127.0.0.1"), - equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), - equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), satisfies(NETWORK_PEER_PORT, val -> assertThat(val).isNotNull())) .hasEventsSatisfyingExactly( event -> From 438728744300cd01eeb4eeb4a8497f11eb228bc8 Mon Sep 17 00:00:00 2001 From: Alex Sweet Date: Mon, 28 Jul 2025 13:16:52 -0700 Subject: [PATCH 23/24] Fix tests --- .../armeria/grpc/v1_14/ArmeriaGrpcTest.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java b/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java index 418a330b1c2d..9dddec381680 100644 --- a/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java +++ b/instrumentation/armeria/armeria-grpc-1.14/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/armeria/grpc/v1_14/ArmeriaGrpcTest.java @@ -89,10 +89,10 @@ void grpcInstrumentation() { equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), + equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), + equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "127.0.0.1"), equalTo(SERVER_PORT, (long) server.httpPort())) - equalTo(RPC_RESPONSE_BODY_SIZE, responseSerializedSize), - equalTo(RPC_REQUEST_BODY_SIZE, requestSerializedSize)) .hasEventsSatisfyingExactly( event -> event @@ -116,10 +116,10 @@ void grpcInstrumentation() { equalTo(RPC_SERVICE, "example.Greeter"), equalTo(RPC_METHOD, "SayHello"), equalTo(RPC_GRPC_STATUS_CODE, (long) Status.Code.OK.value()), + equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), + equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize), equalTo(SERVER_ADDRESS, "127.0.0.1"), equalTo(SERVER_PORT, server.httpPort())) - equalTo(RPC_REQUEST_BODY_SIZE, responseSerializedSize), - equalTo(RPC_RESPONSE_BODY_SIZE, requestSerializedSize)) .hasEventsSatisfyingExactly( event -> event From 484f0e86fb535a1bf8fd5ec77d514812f3e47aad Mon Sep 17 00:00:00 2001 From: Alex Sweet Date: Mon, 28 Jul 2025 14:50:04 -0700 Subject: [PATCH 24/24] Remove newlines --- .../opentelemetry-instrumentation-annotations.txt | 2 +- .../current_vs_latest/opentelemetry-instrumentation-api.txt | 2 +- .../opentelemetry-spring-boot-autoconfigure.txt | 2 +- .../current_vs_latest/opentelemetry-spring-boot-starter.txt | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-annotations.txt b/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-annotations.txt index 62ab6f578fc2..e1d0a8a76701 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-annotations.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-annotations.txt @@ -1,2 +1,2 @@ Comparing source compatibility of opentelemetry-instrumentation-annotations-2.19.0-SNAPSHOT.jar against opentelemetry-instrumentation-annotations-2.18.1.jar -No changes. +No changes. \ No newline at end of file diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-api.txt b/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-api.txt index 7ada78cc00ef..7f6c2469d18e 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-api.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-api.txt @@ -1,2 +1,2 @@ Comparing source compatibility of opentelemetry-instrumentation-api-2.19.0-SNAPSHOT.jar against opentelemetry-instrumentation-api-2.18.1.jar -No changes. +No changes. \ No newline at end of file diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-autoconfigure.txt b/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-autoconfigure.txt index 8c2f4c7332bf..1bd91e0f9c39 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-autoconfigure.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-autoconfigure.txt @@ -1,2 +1,2 @@ Comparing source compatibility of opentelemetry-spring-boot-autoconfigure-2.19.0-SNAPSHOT.jar against opentelemetry-spring-boot-autoconfigure-2.18.1.jar -No changes. +No changes. \ No newline at end of file diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-starter.txt b/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-starter.txt index 2dea386b43c3..85aa35209a8a 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-starter.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-spring-boot-starter.txt @@ -1,2 +1,2 @@ Comparing source compatibility of opentelemetry-spring-boot-starter-2.19.0-SNAPSHOT.jar against opentelemetry-spring-boot-starter-2.18.1.jar -No changes. +No changes. \ No newline at end of file