diff --git a/CHANGELOG.md b/CHANGELOG.md index 90aca708dc7..f8a9b967536 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -47,6 +47,9 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm - Update `http.route` attribute to support `request.Pattern` in `go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux`. (#7108) - Change the default span name to be `GET /path` so it complies with the HTTP semantic conventions in `go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin`. (#6381) - Set `url.scheme` attribute to the request URL.Scheme when possible for HTTP client metrics in `go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp`. (#6938) +- The semantic conventions have been upgraded from `v1.17.0` to `v1.30.0` in `go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc`. (#7270) + - All `net.peer.*` and `net.host.*` attributes are now set to correct `server.*` attributes. + - No `net.socket.*` attributes are set. ### Fixed @@ -98,6 +101,8 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm - The deprecated `SemVersion` function is removed in `go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/test`, use `Version` function instead. (#7143) - The deprecated `SQSAttributeSetter` function is removed in `go.opentelemetry.io/contrib/instrumentation/github.com/aws/aws-sdk-go-v2/otelaws` package, use `SQSAttributeBuilder` instead. (#7145) - The deprecated `SemVersion` function is removed in `go.opentelemetry.io/contrib/instrumentation/host` package, use `Version` instead. (#7203) +- The `GRPCStatusCodeKey` constant from `go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc` is removed. + Use `semconv.RPCGRPCStatusCodeKey` from `go.opentelemetry.io/otel/semconv/*` instead. (#7270) diff --git a/instrumentation/google.golang.org/grpc/otelgrpc/config.go b/instrumentation/google.golang.org/grpc/otelgrpc/config.go index 768160b0c70..296407f38e1 100644 --- a/instrumentation/google.golang.org/grpc/otelgrpc/config.go +++ b/instrumentation/google.golang.org/grpc/otelgrpc/config.go @@ -13,12 +13,8 @@ import ( "go.opentelemetry.io/otel/trace" ) -const ( - // ScopeName is the instrumentation scope name. - ScopeName = "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc" - // GRPCStatusCodeKey is convention for numeric status code of a gRPC request. - GRPCStatusCodeKey = attribute.Key("rpc.grpc.status_code") -) +// ScopeName is the instrumentation scope name. +const ScopeName = "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc" // InterceptorFilter is a predicate used to determine whether a given request in // interceptor info should be instrumented. A InterceptorFilter must return true if diff --git a/instrumentation/google.golang.org/grpc/otelgrpc/interceptor.go b/instrumentation/google.golang.org/grpc/otelgrpc/interceptor.go index 820ce1837df..f63513d456c 100644 --- a/instrumentation/google.golang.org/grpc/otelgrpc/interceptor.go +++ b/instrumentation/google.golang.org/grpc/otelgrpc/interceptor.go @@ -22,7 +22,7 @@ import ( "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/internal" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" - semconv "go.opentelemetry.io/otel/semconv/v1.17.0" + semconv "go.opentelemetry.io/otel/semconv/v1.30.0" "go.opentelemetry.io/otel/trace" ) @@ -37,13 +37,13 @@ func (m messageType) Event(ctx context.Context, id int, _ interface{}) { } span.AddEvent("message", trace.WithAttributes( attribute.KeyValue(m), - RPCMessageIDKey.Int(id), + semconv.RPCMessageIDKey.Int(id), )) } var ( - messageSent = messageType(RPCMessageTypeSent) - messageReceived = messageType(RPCMessageTypeReceived) + messageSent = messageType(semconv.RPCMessageTypeSent) + messageReceived = messageType(semconv.RPCMessageTypeReceived) ) // clientStream wraps around the embedded grpc.ClientStream, and intercepts the RecvMsg and @@ -305,46 +305,32 @@ func StreamServerInterceptor(opts ...Option) grpc.StreamServerInterceptor { // telemetryAttributes returns a span name and span and metric attributes from // the gRPC method and peer address. -func telemetryAttributes(fullMethod, peerAddress string) (string, []attribute.KeyValue) { +func telemetryAttributes(fullMethod, sererAddr string) (string, []attribute.KeyValue) { name, methodAttrs := internal.ParseFullMethod(fullMethod) - peerAttrs := peerAttr(peerAddress) + srvAttrs := serverAddrAttrs(sererAddr) - attrs := make([]attribute.KeyValue, 0, 1+len(methodAttrs)+len(peerAttrs)) - attrs = append(attrs, RPCSystemGRPC) + attrs := make([]attribute.KeyValue, 0, 1+len(methodAttrs)+len(srvAttrs)) + attrs = append(attrs, semconv.RPCSystemGRPC) attrs = append(attrs, methodAttrs...) - attrs = append(attrs, peerAttrs...) + attrs = append(attrs, srvAttrs...) return name, attrs } -// peerAttr returns attributes about the peer address. -func peerAttr(addr string) []attribute.KeyValue { - host, p, err := net.SplitHostPort(addr) +// serverAddrAttrs returns the server address attributes for the hostport. +func serverAddrAttrs(hostport string) []attribute.KeyValue { + h, pStr, err := net.SplitHostPort(hostport) if err != nil { - return nil + // The server.address attribute is required. + return []attribute.KeyValue{semconv.ServerAddress(hostport)} } - - if host == "" { - host = "127.0.0.1" - } - port, err := strconv.Atoi(p) + p, err := strconv.Atoi(pStr) if err != nil { - return nil + return []attribute.KeyValue{semconv.ServerAddress(h)} } - - var attr []attribute.KeyValue - if ip := net.ParseIP(host); ip != nil { - attr = []attribute.KeyValue{ - semconv.NetSockPeerAddr(host), - semconv.NetSockPeerPort(port), - } - } else { - attr = []attribute.KeyValue{ - semconv.NetPeerName(host), - semconv.NetPeerPort(port), - } + return []attribute.KeyValue{ + semconv.ServerAddress(h), + semconv.ServerPort(p), } - - return attr } // peerFromCtx returns a peer address from a context, if one exists. @@ -358,7 +344,7 @@ func peerFromCtx(ctx context.Context) string { // statusCodeAttr returns status code attribute based on given gRPC code. func statusCodeAttr(c grpc_codes.Code) attribute.KeyValue { - return GRPCStatusCodeKey.Int64(int64(c)) + return semconv.RPCGRPCStatusCodeKey.Int64(int64(c)) } // serverStatus returns a span status code and message for a given gRPC diff --git a/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse.go b/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse.go index 0678d4dfe76..1fa73c2f943 100644 --- a/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse.go +++ b/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse.go @@ -8,7 +8,7 @@ import ( "strings" "go.opentelemetry.io/otel/attribute" - semconv "go.opentelemetry.io/otel/semconv/v1.17.0" + semconv "go.opentelemetry.io/otel/semconv/v1.30.0" ) // ParseFullMethod returns a span name following the OpenTelemetry semantic diff --git a/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse_test.go b/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse_test.go index aa52757a9f7..8ff3dcecc04 100644 --- a/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse_test.go +++ b/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse_test.go @@ -7,7 +7,7 @@ import ( "testing" "go.opentelemetry.io/otel/attribute" - semconv "go.opentelemetry.io/otel/semconv/v1.17.0" + semconv "go.opentelemetry.io/otel/semconv/v1.30.0" "github.com/stretchr/testify/assert" ) diff --git a/instrumentation/google.golang.org/grpc/otelgrpc/semconv.go b/instrumentation/google.golang.org/grpc/otelgrpc/semconv.go deleted file mode 100644 index 409c621b74c..00000000000 --- a/instrumentation/google.golang.org/grpc/otelgrpc/semconv.go +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright The OpenTelemetry Authors -// SPDX-License-Identifier: Apache-2.0 - -package otelgrpc // import "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc" - -import ( - "go.opentelemetry.io/otel/attribute" - semconv "go.opentelemetry.io/otel/semconv/v1.17.0" -) - -// Semantic conventions for attribute keys for gRPC. -const ( - // Name of message transmitted or received. - RPCNameKey = attribute.Key("name") - - // Type of message transmitted or received. - RPCMessageTypeKey = attribute.Key("message.type") - - // Identifier of message transmitted or received. - RPCMessageIDKey = attribute.Key("message.id") - - // The compressed size of the message transmitted or received in bytes. - RPCMessageCompressedSizeKey = attribute.Key("message.compressed_size") - - // The uncompressed size of the message transmitted or received in - // bytes. - RPCMessageUncompressedSizeKey = attribute.Key("message.uncompressed_size") -) - -// Semantic conventions for common RPC attributes. -var ( - // Semantic convention for gRPC as the remoting system. - RPCSystemGRPC = semconv.RPCSystemGRPC - - // Semantic convention for a message named message. - RPCNameMessage = RPCNameKey.String("message") - - // Semantic conventions for RPC message types. - RPCMessageTypeSent = RPCMessageTypeKey.String("SENT") - RPCMessageTypeReceived = RPCMessageTypeKey.String("RECEIVED") -) diff --git a/instrumentation/google.golang.org/grpc/otelgrpc/stats_handler.go b/instrumentation/google.golang.org/grpc/otelgrpc/stats_handler.go index a1686ef8b52..9bec51df339 100644 --- a/instrumentation/google.golang.org/grpc/otelgrpc/stats_handler.go +++ b/instrumentation/google.golang.org/grpc/otelgrpc/stats_handler.go @@ -18,7 +18,7 @@ import ( "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/metric" "go.opentelemetry.io/otel/metric/noop" - semconv "go.opentelemetry.io/otel/semconv/v1.17.0" + semconv "go.opentelemetry.io/otel/semconv/v1.30.0" "go.opentelemetry.io/otel/trace" "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/internal" @@ -63,9 +63,9 @@ func NewServerHandler(opts ...Option) stats.Handler { var err error h.duration, err = meter.Float64Histogram( - "rpc.server.duration", - metric.WithDescription("Measures the duration of inbound RPC."), - metric.WithUnit("ms"), + semconv.RPCServerDurationName, + metric.WithDescription(semconv.RPCServerDurationDescription), + metric.WithUnit(semconv.RPCServerDurationUnit), ) if err != nil { otel.Handle(err) @@ -75,9 +75,9 @@ func NewServerHandler(opts ...Option) stats.Handler { } h.inSize, err = meter.Int64Histogram( - "rpc.server.request.size", - metric.WithDescription("Measures size of RPC request messages (uncompressed)."), - metric.WithUnit("By"), + semconv.RPCServerRequestSizeName, + metric.WithDescription(semconv.RPCServerRequestSizeDescription), + metric.WithUnit(semconv.RPCServerRequestSizeUnit), ) if err != nil { otel.Handle(err) @@ -87,9 +87,9 @@ func NewServerHandler(opts ...Option) stats.Handler { } h.outSize, err = meter.Int64Histogram( - "rpc.server.response.size", - metric.WithDescription("Measures size of RPC response messages (uncompressed)."), - metric.WithUnit("By"), + semconv.RPCServerResponseSizeName, + metric.WithDescription(semconv.RPCServerResponseSizeDescription), + metric.WithUnit(semconv.RPCServerResponseSizeUnit), ) if err != nil { otel.Handle(err) @@ -99,9 +99,9 @@ func NewServerHandler(opts ...Option) stats.Handler { } h.inMsg, err = meter.Int64Histogram( - "rpc.server.requests_per_rpc", - metric.WithDescription("Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs."), - metric.WithUnit("{count}"), + semconv.RPCServerRequestsPerRPCName, + metric.WithDescription(semconv.RPCServerRequestsPerRPCDescription), + metric.WithUnit(semconv.RPCServerRequestsPerRPCUnit), ) if err != nil { otel.Handle(err) @@ -111,9 +111,9 @@ func NewServerHandler(opts ...Option) stats.Handler { } h.outMsg, err = meter.Int64Histogram( - "rpc.server.responses_per_rpc", - metric.WithDescription("Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs."), - metric.WithUnit("{count}"), + semconv.RPCServerResponsesPerRPCName, + metric.WithDescription(semconv.RPCServerResponsesPerRPCDescription), + metric.WithUnit(semconv.RPCServerResponsesPerRPCUnit), ) if err != nil { otel.Handle(err) @@ -139,7 +139,7 @@ func (h *serverHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) cont ctx = extract(ctx, h.Propagators) name, attrs := internal.ParseFullMethod(info.FullMethodName) - attrs = append(attrs, RPCSystemGRPC) + attrs = append(attrs, semconv.RPCSystemGRPC) record := true if h.Filter != nil { @@ -198,9 +198,9 @@ func NewClientHandler(opts ...Option) stats.Handler { var err error h.duration, err = meter.Float64Histogram( - "rpc.client.duration", - metric.WithDescription("Measures the duration of inbound RPC."), - metric.WithUnit("ms"), + semconv.RPCClientDurationName, + metric.WithDescription(semconv.RPCClientDurationDescription), + metric.WithUnit(semconv.RPCClientDurationUnit), ) if err != nil { otel.Handle(err) @@ -210,9 +210,9 @@ func NewClientHandler(opts ...Option) stats.Handler { } h.outSize, err = meter.Int64Histogram( - "rpc.client.request.size", - metric.WithDescription("Measures size of RPC request messages (uncompressed)."), - metric.WithUnit("By"), + semconv.RPCClientRequestSizeName, + metric.WithDescription(semconv.RPCClientRequestSizeDescription), + metric.WithUnit(semconv.RPCClientRequestSizeUnit), ) if err != nil { otel.Handle(err) @@ -222,9 +222,9 @@ func NewClientHandler(opts ...Option) stats.Handler { } h.inSize, err = meter.Int64Histogram( - "rpc.client.response.size", - metric.WithDescription("Measures size of RPC response messages (uncompressed)."), - metric.WithUnit("By"), + semconv.RPCClientResponseSizeName, + metric.WithDescription(semconv.RPCClientResponseSizeDescription), + metric.WithUnit(semconv.RPCClientResponseSizeUnit), ) if err != nil { otel.Handle(err) @@ -234,9 +234,9 @@ func NewClientHandler(opts ...Option) stats.Handler { } h.outMsg, err = meter.Int64Histogram( - "rpc.client.requests_per_rpc", - metric.WithDescription("Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs."), - metric.WithUnit("{count}"), + semconv.RPCClientRequestsPerRPCName, + metric.WithDescription(semconv.RPCClientRequestsPerRPCDescription), + metric.WithUnit(semconv.RPCClientRequestsPerRPCUnit), ) if err != nil { otel.Handle(err) @@ -246,9 +246,9 @@ func NewClientHandler(opts ...Option) stats.Handler { } h.inMsg, err = meter.Int64Histogram( - "rpc.client.responses_per_rpc", - metric.WithDescription("Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs."), - metric.WithUnit("{count}"), + semconv.RPCClientResponsesPerRPCName, + metric.WithDescription(semconv.RPCClientResponsesPerRPCDescription), + metric.WithUnit(semconv.RPCClientResponsesPerRPCUnit), ) if err != nil { otel.Handle(err) @@ -263,7 +263,7 @@ func NewClientHandler(opts ...Option) stats.Handler { // TagRPC can attach some information to the given context. func (h *clientHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context { name, attrs := internal.ParseFullMethod(info.FullMethodName) - attrs = append(attrs, RPCSystemGRPC) + attrs = append(attrs, semconv.RPCSystemGRPC) record := true if h.Filter != nil { @@ -333,10 +333,10 @@ func (c *config) handleRPC( if c.ReceivedEvent && span.IsRecording() { span.AddEvent("message", trace.WithAttributes( - semconv.MessageTypeReceived, - semconv.MessageIDKey.Int64(messageId), - semconv.MessageCompressedSizeKey.Int(rs.CompressedLength), - semconv.MessageUncompressedSizeKey.Int(rs.Length), + semconv.RPCMessageTypeReceived, + semconv.RPCMessageIDKey.Int64(messageId), + semconv.RPCMessageCompressedSizeKey.Int(rs.CompressedLength), + semconv.RPCMessageUncompressedSizeKey.Int(rs.Length), ), ) } @@ -349,10 +349,10 @@ func (c *config) handleRPC( if c.SentEvent && span.IsRecording() { span.AddEvent("message", trace.WithAttributes( - semconv.MessageTypeSent, - semconv.MessageIDKey.Int64(messageId), - semconv.MessageCompressedSizeKey.Int(rs.CompressedLength), - semconv.MessageUncompressedSizeKey.Int(rs.Length), + semconv.RPCMessageTypeSent, + semconv.RPCMessageIDKey.Int64(messageId), + semconv.RPCMessageCompressedSizeKey.Int(rs.CompressedLength), + semconv.RPCMessageUncompressedSizeKey.Int(rs.Length), ), ) } @@ -360,7 +360,7 @@ func (c *config) handleRPC( case *stats.OutHeader: if span.IsRecording() { if p, ok := peer.FromContext(ctx); ok { - span.SetAttributes(peerAttr(p.Addr.String())...) + span.SetAttributes(serverAddrAttrs(p.Addr.String())...) } } case *stats.End: diff --git a/instrumentation/google.golang.org/grpc/otelgrpc/test/grpc_stats_handler_test.go b/instrumentation/google.golang.org/grpc/otelgrpc/test/grpc_stats_handler_test.go index e434b43998d..eeaa60332b5 100644 --- a/instrumentation/google.golang.org/grpc/otelgrpc/test/grpc_stats_handler_test.go +++ b/instrumentation/google.golang.org/grpc/otelgrpc/test/grpc_stats_handler_test.go @@ -27,7 +27,7 @@ import ( "go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest" "go.opentelemetry.io/otel/sdk/trace" "go.opentelemetry.io/otel/sdk/trace/tracetest" - semconv "go.opentelemetry.io/otel/semconv/v1.17.0" + semconv "go.opentelemetry.io/otel/semconv/v1.30.0" oteltrace "go.opentelemetry.io/otel/trace" "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc" @@ -157,29 +157,29 @@ func checkClientSpans(t *testing.T, spans []trace.ReadOnlySpan, addr string) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(0), - otelgrpc.RPCMessageUncompressedSizeKey.Int(0), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(0), + semconv.RPCMessageUncompressedSizeKey.Int(0), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(0), - otelgrpc.RPCMessageUncompressedSizeKey.Int(0), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(0), + semconv.RPCMessageUncompressedSizeKey.Int(0), }, }, }, emptySpan.Events()) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethodKey.String("EmptyCall"), semconv.RPCServiceKey.String("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr(host), - semconv.NetSockPeerPort(port), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress(host), + semconv.ServerPort(port), testSpanAttr, }, emptySpan.Attributes()) @@ -190,29 +190,29 @@ func checkClientSpans(t *testing.T, spans []trace.ReadOnlySpan, addr string) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(271840), - otelgrpc.RPCMessageUncompressedSizeKey.Int(271840), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(271840), + semconv.RPCMessageUncompressedSizeKey.Int(271840), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(314167), - otelgrpc.RPCMessageUncompressedSizeKey.Int(314167), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(314167), + semconv.RPCMessageUncompressedSizeKey.Int(314167), }, }, }, largeSpan.Events()) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethodKey.String("UnaryCall"), semconv.RPCServiceKey.String("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr(host), - semconv.NetSockPeerPort(port), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress(host), + semconv.ServerPort(port), testSpanAttr, }, largeSpan.Attributes()) @@ -223,46 +223,46 @@ func checkClientSpans(t *testing.T, spans []trace.ReadOnlySpan, addr string) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(27190), - otelgrpc.RPCMessageUncompressedSizeKey.Int(27190), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(27190), + semconv.RPCMessageUncompressedSizeKey.Int(27190), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(12), - otelgrpc.RPCMessageUncompressedSizeKey.Int(12), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(12), + semconv.RPCMessageUncompressedSizeKey.Int(12), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(1834), - otelgrpc.RPCMessageUncompressedSizeKey.Int(1834), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(1834), + semconv.RPCMessageUncompressedSizeKey.Int(1834), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(45912), - otelgrpc.RPCMessageUncompressedSizeKey.Int(45912), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(45912), + semconv.RPCMessageUncompressedSizeKey.Int(45912), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(4), - otelgrpc.RPCMessageUncompressedSizeKey.Int(4), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(4), + semconv.RPCMessageUncompressedSizeKey.Int(4), }, }, // client does not record an event for the server response. @@ -270,10 +270,10 @@ func checkClientSpans(t *testing.T, spans []trace.ReadOnlySpan, addr string) { assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethodKey.String("StreamingInputCall"), semconv.RPCServiceKey.String("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr(host), - semconv.NetSockPeerPort(port), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress(host), + semconv.ServerPort(port), testSpanAttr, }, streamInput.Attributes()) @@ -284,56 +284,56 @@ func checkClientSpans(t *testing.T, spans []trace.ReadOnlySpan, addr string) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(21), - otelgrpc.RPCMessageUncompressedSizeKey.Int(21), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(21), + semconv.RPCMessageUncompressedSizeKey.Int(21), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(31423), - otelgrpc.RPCMessageUncompressedSizeKey.Int(31423), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(31423), + semconv.RPCMessageUncompressedSizeKey.Int(31423), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(13), - otelgrpc.RPCMessageUncompressedSizeKey.Int(13), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(13), + semconv.RPCMessageUncompressedSizeKey.Int(13), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(2659), - otelgrpc.RPCMessageUncompressedSizeKey.Int(2659), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(2659), + semconv.RPCMessageUncompressedSizeKey.Int(2659), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(58987), - otelgrpc.RPCMessageUncompressedSizeKey.Int(58987), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(58987), + semconv.RPCMessageUncompressedSizeKey.Int(58987), }, }, }, streamOutput.Events()) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethodKey.String("StreamingOutputCall"), semconv.RPCServiceKey.String("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr(host), - semconv.NetSockPeerPort(port), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress(host), + semconv.ServerPort(port), testSpanAttr, }, streamOutput.Attributes()) @@ -344,83 +344,83 @@ func checkClientSpans(t *testing.T, spans []trace.ReadOnlySpan, addr string) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(27196), - otelgrpc.RPCMessageUncompressedSizeKey.Int(27196), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(27196), + semconv.RPCMessageUncompressedSizeKey.Int(27196), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(31423), - otelgrpc.RPCMessageUncompressedSizeKey.Int(31423), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(31423), + semconv.RPCMessageUncompressedSizeKey.Int(31423), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(16), - otelgrpc.RPCMessageUncompressedSizeKey.Int(16), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(16), + semconv.RPCMessageUncompressedSizeKey.Int(16), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(13), - otelgrpc.RPCMessageUncompressedSizeKey.Int(13), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(13), + semconv.RPCMessageUncompressedSizeKey.Int(13), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(1839), - otelgrpc.RPCMessageUncompressedSizeKey.Int(1839), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(1839), + semconv.RPCMessageUncompressedSizeKey.Int(1839), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(2659), - otelgrpc.RPCMessageUncompressedSizeKey.Int(2659), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(2659), + semconv.RPCMessageUncompressedSizeKey.Int(2659), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(45918), - otelgrpc.RPCMessageUncompressedSizeKey.Int(45918), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(45918), + semconv.RPCMessageUncompressedSizeKey.Int(45918), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(58987), - otelgrpc.RPCMessageUncompressedSizeKey.Int(58987), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(58987), + semconv.RPCMessageUncompressedSizeKey.Int(58987), }, }, }, pingPong.Events()) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethodKey.String("FullDuplexCall"), semconv.RPCServiceKey.String("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr(host), - semconv.NetSockPeerPort(port), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress(host), + semconv.ServerPort(port), testSpanAttr, }, pingPong.Attributes()) } @@ -435,30 +435,30 @@ func checkServerSpans(t *testing.T, spans []trace.ReadOnlySpan) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(0), - otelgrpc.RPCMessageUncompressedSizeKey.Int(0), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(0), + semconv.RPCMessageUncompressedSizeKey.Int(0), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(0), - otelgrpc.RPCMessageUncompressedSizeKey.Int(0), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(0), + semconv.RPCMessageUncompressedSizeKey.Int(0), }, }, }, emptySpan.Events()) - port, ok := findAttribute(emptySpan.Attributes(), semconv.NetSockPeerPortKey) + port, ok := findAttribute(emptySpan.Attributes(), semconv.ServerPortKey) assert.True(t, ok) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethodKey.String("EmptyCall"), semconv.RPCServiceKey.String("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr("127.0.0.1"), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress("127.0.0.1"), port, testSpanAttr, }, emptySpan.Attributes()) @@ -470,30 +470,30 @@ func checkServerSpans(t *testing.T, spans []trace.ReadOnlySpan) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageCompressedSizeKey.Int(271840), - otelgrpc.RPCMessageUncompressedSizeKey.Int(271840), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageCompressedSizeKey.Int(271840), + semconv.RPCMessageUncompressedSizeKey.Int(271840), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageCompressedSizeKey.Int(314167), - otelgrpc.RPCMessageUncompressedSizeKey.Int(314167), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageCompressedSizeKey.Int(314167), + semconv.RPCMessageUncompressedSizeKey.Int(314167), }, }, }, largeSpan.Events()) - port, ok = findAttribute(largeSpan.Attributes(), semconv.NetSockPeerPortKey) + port, ok = findAttribute(largeSpan.Attributes(), semconv.ServerPortKey) assert.True(t, ok) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethodKey.String("UnaryCall"), semconv.RPCServiceKey.String("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr("127.0.0.1"), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress("127.0.0.1"), port, testSpanAttr, }, largeSpan.Attributes()) @@ -505,58 +505,58 @@ func checkServerSpans(t *testing.T, spans []trace.ReadOnlySpan) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(27190), - otelgrpc.RPCMessageUncompressedSizeKey.Int(27190), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(27190), + semconv.RPCMessageUncompressedSizeKey.Int(27190), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(12), - otelgrpc.RPCMessageUncompressedSizeKey.Int(12), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(12), + semconv.RPCMessageUncompressedSizeKey.Int(12), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(1834), - otelgrpc.RPCMessageUncompressedSizeKey.Int(1834), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(1834), + semconv.RPCMessageUncompressedSizeKey.Int(1834), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(45912), - otelgrpc.RPCMessageUncompressedSizeKey.Int(45912), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(45912), + semconv.RPCMessageUncompressedSizeKey.Int(45912), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(4), - otelgrpc.RPCMessageUncompressedSizeKey.Int(4), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(4), + semconv.RPCMessageUncompressedSizeKey.Int(4), }, }, // client does not record an event for the server response. }, streamInput.Events()) - port, ok = findAttribute(streamInput.Attributes(), semconv.NetSockPeerPortKey) + port, ok = findAttribute(streamInput.Attributes(), semconv.ServerPortKey) assert.True(t, ok) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethodKey.String("StreamingInputCall"), semconv.RPCServiceKey.String("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr("127.0.0.1"), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress("127.0.0.1"), port, testSpanAttr, }, streamInput.Attributes()) @@ -568,57 +568,57 @@ func checkServerSpans(t *testing.T, spans []trace.ReadOnlySpan) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(21), - otelgrpc.RPCMessageUncompressedSizeKey.Int(21), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(21), + semconv.RPCMessageUncompressedSizeKey.Int(21), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(31423), - otelgrpc.RPCMessageUncompressedSizeKey.Int(31423), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(31423), + semconv.RPCMessageUncompressedSizeKey.Int(31423), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(13), - otelgrpc.RPCMessageUncompressedSizeKey.Int(13), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(13), + semconv.RPCMessageUncompressedSizeKey.Int(13), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(2659), - otelgrpc.RPCMessageUncompressedSizeKey.Int(2659), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(2659), + semconv.RPCMessageUncompressedSizeKey.Int(2659), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(58987), - otelgrpc.RPCMessageUncompressedSizeKey.Int(58987), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(58987), + semconv.RPCMessageUncompressedSizeKey.Int(58987), }, }, }, streamOutput.Events()) - port, ok = findAttribute(streamOutput.Attributes(), semconv.NetSockPeerPortKey) + port, ok = findAttribute(streamOutput.Attributes(), semconv.ServerPortKey) assert.True(t, ok) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethodKey.String("StreamingOutputCall"), semconv.RPCServiceKey.String("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr("127.0.0.1"), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress("127.0.0.1"), port, testSpanAttr, }, streamOutput.Attributes()) @@ -630,84 +630,84 @@ func checkServerSpans(t *testing.T, spans []trace.ReadOnlySpan) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(27196), - otelgrpc.RPCMessageUncompressedSizeKey.Int(27196), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(27196), + semconv.RPCMessageUncompressedSizeKey.Int(27196), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(31423), - otelgrpc.RPCMessageUncompressedSizeKey.Int(31423), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(31423), + semconv.RPCMessageUncompressedSizeKey.Int(31423), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(16), - otelgrpc.RPCMessageUncompressedSizeKey.Int(16), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(16), + semconv.RPCMessageUncompressedSizeKey.Int(16), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(13), - otelgrpc.RPCMessageUncompressedSizeKey.Int(13), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(13), + semconv.RPCMessageUncompressedSizeKey.Int(13), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(1839), - otelgrpc.RPCMessageUncompressedSizeKey.Int(1839), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(1839), + semconv.RPCMessageUncompressedSizeKey.Int(1839), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(2659), - otelgrpc.RPCMessageUncompressedSizeKey.Int(2659), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(2659), + semconv.RPCMessageUncompressedSizeKey.Int(2659), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), - otelgrpc.RPCMessageCompressedSizeKey.Int(45918), - otelgrpc.RPCMessageUncompressedSizeKey.Int(45918), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageCompressedSizeKey.Int(45918), + semconv.RPCMessageUncompressedSizeKey.Int(45918), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("SENT"), - otelgrpc.RPCMessageCompressedSizeKey.Int(58987), - otelgrpc.RPCMessageUncompressedSizeKey.Int(58987), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageCompressedSizeKey.Int(58987), + semconv.RPCMessageUncompressedSizeKey.Int(58987), }, }, }, pingPong.Events()) - port, ok = findAttribute(pingPong.Attributes(), semconv.NetSockPeerPortKey) + port, ok = findAttribute(pingPong.Attributes(), semconv.ServerPortKey) assert.True(t, ok) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethodKey.String("FullDuplexCall"), semconv.RPCServiceKey.String("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr("127.0.0.1"), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress("127.0.0.1"), port, testSpanAttr, }, pingPong.Attributes()) @@ -723,13 +723,13 @@ func checkClientMetrics(t *testing.T, reader metric.Reader) { Scope: instrumentation.Scope{ Name: "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc", Version: otelgrpc.Version(), - SchemaURL: "https://opentelemetry.io/schemas/1.17.0", + SchemaURL: semconv.SchemaURL, }, Metrics: []metricdata.Metrics{ { - Name: "rpc.client.duration", - Description: "Measures the duration of inbound RPC.", - Unit: "ms", + Name: semconv.RPCClientDurationName, + Description: semconv.RPCClientDurationDescription, + Unit: semconv.RPCClientDurationUnit, Data: metricdata.Histogram[float64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[float64]{ @@ -777,9 +777,9 @@ func checkClientMetrics(t *testing.T, reader metric.Reader) { }, }, { - Name: "rpc.client.request.size", - Description: "Measures size of RPC request messages (uncompressed).", - Unit: "By", + Name: semconv.RPCClientRequestSizeName, + Description: semconv.RPCClientRequestSizeDescription, + Unit: semconv.RPCClientRequestSizeUnit, Data: metricdata.Histogram[int64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[int64]{ @@ -852,9 +852,9 @@ func checkClientMetrics(t *testing.T, reader metric.Reader) { }, }, { - Name: "rpc.client.response.size", - Description: "Measures size of RPC response messages (uncompressed).", - Unit: "By", + Name: semconv.RPCClientResponseSizeName, + Description: semconv.RPCClientResponseSizeDescription, + Unit: semconv.RPCClientResponseSizeUnit, Data: metricdata.Histogram[int64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[int64]{ @@ -927,9 +927,9 @@ func checkClientMetrics(t *testing.T, reader metric.Reader) { }, }, { - Name: "rpc.client.requests_per_rpc", - Description: "Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs.", - Unit: "{count}", + Name: semconv.RPCClientRequestsPerRPCName, + Description: semconv.RPCClientRequestsPerRPCDescription, + Unit: semconv.RPCClientRequestsPerRPCUnit, Data: metricdata.Histogram[int64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[int64]{ @@ -1007,9 +1007,9 @@ func checkClientMetrics(t *testing.T, reader metric.Reader) { }, }, { - Name: "rpc.client.responses_per_rpc", - Description: "Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs.", - Unit: "{count}", + Name: semconv.RPCClientResponsesPerRPCName, + Description: semconv.RPCClientResponsesPerRPCDescription, + Unit: semconv.RPCClientResponsesPerRPCUnit, Data: metricdata.Histogram[int64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[int64]{ @@ -1101,13 +1101,13 @@ func checkServerMetrics(t *testing.T, reader metric.Reader) { Scope: instrumentation.Scope{ Name: "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc", Version: otelgrpc.Version(), - SchemaURL: "https://opentelemetry.io/schemas/1.17.0", + SchemaURL: semconv.SchemaURL, }, Metrics: []metricdata.Metrics{ { - Name: "rpc.server.duration", - Description: "Measures the duration of inbound RPC.", - Unit: "ms", + Name: semconv.RPCServerDurationName, + Description: semconv.RPCServerDurationDescription, + Unit: semconv.RPCServerDurationUnit, Data: metricdata.Histogram[float64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[float64]{ @@ -1155,9 +1155,9 @@ func checkServerMetrics(t *testing.T, reader metric.Reader) { }, }, { - Name: "rpc.server.request.size", - Description: "Measures size of RPC request messages (uncompressed).", - Unit: "By", + Name: semconv.RPCServerRequestSizeName, + Description: semconv.RPCServerRequestSizeDescription, + Unit: semconv.RPCServerRequestSizeUnit, Data: metricdata.Histogram[int64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[int64]{ @@ -1230,9 +1230,9 @@ func checkServerMetrics(t *testing.T, reader metric.Reader) { }, }, { - Name: "rpc.server.response.size", - Description: "Measures size of RPC response messages (uncompressed).", - Unit: "By", + Name: semconv.RPCServerResponseSizeName, + Description: semconv.RPCServerResponseSizeDescription, + Unit: semconv.RPCServerResponseSizeUnit, Data: metricdata.Histogram[int64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[int64]{ @@ -1305,9 +1305,9 @@ func checkServerMetrics(t *testing.T, reader metric.Reader) { }, }, { - Name: "rpc.server.requests_per_rpc", - Description: "Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs.", - Unit: "{count}", + Name: semconv.RPCServerRequestsPerRPCName, + Description: semconv.RPCServerRequestsPerRPCDescription, + Unit: semconv.RPCServerRequestsPerRPCUnit, Data: metricdata.Histogram[int64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[int64]{ @@ -1385,9 +1385,9 @@ func checkServerMetrics(t *testing.T, reader metric.Reader) { }, }, { - Name: "rpc.server.responses_per_rpc", - Description: "Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs.", - Unit: "{count}", + Name: semconv.RPCServerResponsesPerRPCName, + Description: semconv.RPCServerResponsesPerRPCDescription, + Unit: semconv.RPCServerResponsesPerRPCUnit, Data: metricdata.Histogram[int64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[int64]{ diff --git a/instrumentation/google.golang.org/grpc/otelgrpc/test/grpc_test.go b/instrumentation/google.golang.org/grpc/otelgrpc/test/grpc_test.go index 0522ca3ca96..3f4ce9ef813 100644 --- a/instrumentation/google.golang.org/grpc/otelgrpc/test/grpc_test.go +++ b/instrumentation/google.golang.org/grpc/otelgrpc/test/grpc_test.go @@ -12,7 +12,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "google.golang.org/grpc" - "google.golang.org/grpc/codes" "google.golang.org/grpc/credentials/insecure" "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc" @@ -21,14 +20,14 @@ import ( "go.opentelemetry.io/otel/sdk/instrumentation" "go.opentelemetry.io/otel/sdk/trace" "go.opentelemetry.io/otel/sdk/trace/tracetest" - semconv "go.opentelemetry.io/otel/semconv/v1.17.0" + semconv "go.opentelemetry.io/otel/semconv/v1.30.0" pb "google.golang.org/grpc/interop/grpc_testing" ) var wantInstrumentationScope = instrumentation.Scope{ Name: "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc", - SchemaURL: "https://opentelemetry.io/schemas/1.17.0", + SchemaURL: semconv.SchemaURL, Version: otelgrpc.Version(), } @@ -131,29 +130,29 @@ func checkStreamClientSpans(t *testing.T, spans []trace.ReadOnlySpan, addr strin { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("SENT"), }, }, // client does not record an event for the server response. @@ -161,10 +160,10 @@ func checkStreamClientSpans(t *testing.T, spans []trace.ReadOnlySpan, addr strin assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethod("StreamingInputCall"), semconv.RPCService("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr(host), - semconv.NetSockPeerPort(port), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress(host), + semconv.ServerPort(port), }, streamInput.Attributes()) streamOutput := spans[1] @@ -175,46 +174,46 @@ func checkStreamClientSpans(t *testing.T, spans []trace.ReadOnlySpan, addr strin { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, }, streamOutput.Events()) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethod("StreamingOutputCall"), semconv.RPCService("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr(host), - semconv.NetSockPeerPort(port), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress(host), + semconv.ServerPort(port), }, streamOutput.Attributes()) pingPong := spans[2] @@ -224,67 +223,67 @@ func checkStreamClientSpans(t *testing.T, spans []trace.ReadOnlySpan, addr strin { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, }, pingPong.Events()) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethod("FullDuplexCall"), semconv.RPCService("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr(host), - semconv.NetSockPeerPort(port), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress(host), + semconv.ServerPort(port), }, pingPong.Attributes()) } @@ -299,48 +298,48 @@ func checkStreamServerSpans(t *testing.T, spans []trace.ReadOnlySpan) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), }, }, }, streamInput.Events()) - port, ok := findAttribute(streamInput.Attributes(), semconv.NetSockPeerPortKey) + port, ok := findAttribute(streamInput.Attributes(), semconv.ServerPortKey) assert.True(t, ok) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethod("StreamingInputCall"), semconv.RPCService("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr("127.0.0.1"), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress("127.0.0.1"), port, }, streamInput.Attributes()) @@ -352,49 +351,49 @@ func checkStreamServerSpans(t *testing.T, spans []trace.ReadOnlySpan) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("SENT"), }, }, }, streamOutput.Events()) - port, ok = findAttribute(streamOutput.Attributes(), semconv.NetSockPeerPortKey) + port, ok = findAttribute(streamOutput.Attributes(), semconv.ServerPortKey) assert.True(t, ok) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethod("StreamingOutputCall"), semconv.RPCService("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr("127.0.0.1"), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress("127.0.0.1"), port, }, streamOutput.Attributes()) @@ -405,68 +404,68 @@ func checkStreamServerSpans(t *testing.T, spans []trace.ReadOnlySpan) { { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(1), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(1), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(2), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(2), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(3), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(3), + semconv.RPCMessageTypeKey.String("SENT"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("RECEIVED"), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("RECEIVED"), }, }, { Name: "message", Attributes: []attribute.KeyValue{ - otelgrpc.RPCMessageIDKey.Int(4), - otelgrpc.RPCMessageTypeKey.String("SENT"), + semconv.RPCMessageIDKey.Int(4), + semconv.RPCMessageTypeKey.String("SENT"), }, }, }, pingPong.Events()) - port, ok = findAttribute(pingPong.Attributes(), semconv.NetSockPeerPortKey) + port, ok = findAttribute(pingPong.Attributes(), semconv.ServerPortKey) assert.True(t, ok) assert.ElementsMatch(t, []attribute.KeyValue{ semconv.RPCMethod("FullDuplexCall"), semconv.RPCService("grpc.testing.TestService"), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(codes.OK)), - semconv.NetSockPeerAddr("127.0.0.1"), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeOk, + semconv.ServerAddress("127.0.0.1"), port, }, pingPong.Attributes()) } diff --git a/instrumentation/google.golang.org/grpc/otelgrpc/test/interceptor_test.go b/instrumentation/google.golang.org/grpc/otelgrpc/test/interceptor_test.go index fbcc7db644d..adabb3f54b3 100644 --- a/instrumentation/google.golang.org/grpc/otelgrpc/test/interceptor_test.go +++ b/instrumentation/google.golang.org/grpc/otelgrpc/test/interceptor_test.go @@ -17,7 +17,7 @@ import ( "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/sdk/trace" "go.opentelemetry.io/otel/sdk/trace/tracetest" - semconv "go.opentelemetry.io/otel/semconv/v1.17.0" + semconv "go.opentelemetry.io/otel/semconv/v1.30.0" oteltrace "go.opentelemetry.io/otel/trace" "github.com/stretchr/testify/assert" @@ -172,11 +172,11 @@ func TestStreamClientInterceptorOnBIDIStream(t *testing.T) { expectedAttr := []attribute.KeyValue{ semconv.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(grpc_codes.OK)), + semconv.RPCGRPCStatusCodeOk, semconv.RPCService("github.com.serviceName"), semconv.RPCMethod("bar"), - semconv.NetPeerName("fake"), - semconv.NetPeerPort(8906), + semconv.ServerAddress("fake"), + semconv.ServerPort(8906), attribute.Bool("custom", true), } assert.ElementsMatch(t, expectedAttr, span.Attributes()) @@ -188,10 +188,10 @@ func TestStreamClientInterceptorOnBIDIStream(t *testing.T) { validate := func(eventName string, attrs []attribute.KeyValue) { for _, kv := range attrs { k, v := kv.Key, kv.Value - if k == otelgrpc.RPCMessageTypeKey && v.AsString() != eventName { + if k == semconv.RPCMessageTypeKey && v.AsString() != eventName { t.Errorf("invalid event on index: %d expecting %s event, receive %s event", i, eventName, v.AsString()) } - if k == otelgrpc.RPCMessageIDKey && v != attribute.IntValue(msgID) { + if k == semconv.RPCMessageIDKey && v != attribute.IntValue(msgID) { t.Errorf("invalid id for message event expected %d received %d", msgID, v.AsInt64()) } } @@ -237,15 +237,15 @@ func TestStreamClientInterceptorEvents(t *testing.T) { case otelgrpc.SentEvents: eventsAttr = append(eventsAttr, map[attribute.Key]attribute.Value{ - otelgrpc.RPCMessageTypeKey: attribute.StringValue("SENT"), - otelgrpc.RPCMessageIDKey: attribute.IntValue(1), + semconv.RPCMessageTypeKey: attribute.StringValue("SENT"), + semconv.RPCMessageIDKey: attribute.IntValue(1), }, ) case otelgrpc.ReceivedEvents: eventsAttr = append(eventsAttr, map[attribute.Key]attribute.Value{ - otelgrpc.RPCMessageTypeKey: attribute.StringValue("RECEIVED"), - otelgrpc.RPCMessageIDKey: attribute.IntValue(1), + semconv.RPCMessageTypeKey: attribute.StringValue("RECEIVED"), + semconv.RPCMessageIDKey: attribute.IntValue(1), }, ) } @@ -312,11 +312,11 @@ func TestStreamClientInterceptorOnUnidirectionalClientServerStream(t *testing.T) expectedAttr := []attribute.KeyValue{ semconv.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(grpc_codes.OK)), + semconv.RPCGRPCStatusCodeOk, semconv.RPCService("github.com.serviceName"), semconv.RPCMethod("bar"), - semconv.NetPeerName("fake"), - semconv.NetPeerPort(8906), + semconv.ServerAddress("fake"), + semconv.ServerPort(8906), attribute.Bool("custom", true), } assert.ElementsMatch(t, expectedAttr, span.Attributes()) @@ -329,10 +329,10 @@ func TestStreamClientInterceptorOnUnidirectionalClientServerStream(t *testing.T) validate := func(eventName string, attrs []attribute.KeyValue) { for _, kv := range attrs { k, v := kv.Key, kv.Value - if k == otelgrpc.RPCMessageTypeKey && v.AsString() != eventName { + if k == semconv.RPCMessageTypeKey && v.AsString() != eventName { t.Errorf("invalid event on index: %d expecting %s event, receive %s event", i, eventName, v.AsString()) } - if k == otelgrpc.RPCMessageIDKey && v != attribute.IntValue(msgID) { + if k == semconv.RPCMessageIDKey && v != attribute.IntValue(msgID) { t.Errorf("invalid id for message event expected %d received %d", msgID, v.AsInt64()) } } @@ -452,11 +452,11 @@ func TestStreamClientInterceptorWithError(t *testing.T) { expectedAttr := []attribute.KeyValue{ semconv.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(grpc_codes.Unknown)), + semconv.RPCGRPCStatusCodeUnknown, semconv.RPCService("github.com.serviceName"), semconv.RPCMethod("bar"), - semconv.NetPeerName("fake"), - semconv.NetPeerPort(8906), + semconv.ServerAddress("fake"), + semconv.ServerPort(8906), } assert.ElementsMatch(t, expectedAttr, span.Attributes()) assert.Equal(t, codes.Error, span.Status().Code) @@ -562,7 +562,7 @@ func assertServerSpan(t *testing.T, wantSpanCode codes.Code, wantSpanStatusDescr // validate grpc code span attribute var codeAttr attribute.KeyValue for _, a := range span.Attributes() { - if a.Key == otelgrpc.GRPCStatusCodeKey { + if a.Key == semconv.RPCGRPCStatusCodeKey { codeAttr = a break } @@ -668,13 +668,13 @@ func TestStreamServerInterceptorEvents(t *testing.T) { switch event { case otelgrpc.SentEvents: eventsAttr = append(eventsAttr, map[attribute.Key]attribute.Value{ - otelgrpc.RPCMessageTypeKey: attribute.StringValue("SENT"), - otelgrpc.RPCMessageIDKey: attribute.IntValue(1), + semconv.RPCMessageTypeKey: attribute.StringValue("SENT"), + semconv.RPCMessageIDKey: attribute.IntValue(1), }) case otelgrpc.ReceivedEvents: eventsAttr = append(eventsAttr, map[attribute.Key]attribute.Value{ - otelgrpc.RPCMessageTypeKey: attribute.StringValue("RECEIVED"), - otelgrpc.RPCMessageIDKey: attribute.IntValue(1), + semconv.RPCMessageTypeKey: attribute.StringValue("RECEIVED"), + semconv.RPCMessageIDKey: attribute.IntValue(1), }) } } diff --git a/instrumentation/google.golang.org/grpc/otelgrpc/test/stats_handler_test.go b/instrumentation/google.golang.org/grpc/otelgrpc/test/stats_handler_test.go index 1f96bbd4f8e..4ca0ab845b6 100644 --- a/instrumentation/google.golang.org/grpc/otelgrpc/test/stats_handler_test.go +++ b/instrumentation/google.golang.org/grpc/otelgrpc/test/stats_handler_test.go @@ -9,7 +9,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - grpc_codes "google.golang.org/grpc/codes" + "google.golang.org/grpc/codes" "google.golang.org/grpc/stats" "google.golang.org/grpc/status" @@ -20,7 +20,7 @@ import ( "go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest" "go.opentelemetry.io/otel/sdk/trace" "go.opentelemetry.io/otel/sdk/trace/tracetest" - semconv "go.opentelemetry.io/otel/semconv/v1.17.0" + semconv "go.opentelemetry.io/otel/semconv/v1.30.0" ) func TestStatsHandlerHandleRPCServerErrors(t *testing.T) { @@ -64,14 +64,14 @@ func TestStatsHandlerHandleRPCServerErrors(t *testing.T) { } } -func assertStatsHandlerServerMetrics(t *testing.T, reader metric.Reader, serviceName, name string, code grpc_codes.Code) { +func assertStatsHandlerServerMetrics(t *testing.T, reader metric.Reader, serviceName, name string, code codes.Code) { want := metricdata.ScopeMetrics{ Scope: wantInstrumentationScope, Metrics: []metricdata.Metrics{ { - Name: "rpc.server.duration", - Description: "Measures the duration of inbound RPC.", - Unit: "ms", + Name: string(semconv.RPCServerDurationName), + Description: string(semconv.RPCServerDurationDescription), + Unit: string(semconv.RPCServerDurationUnit), Data: metricdata.Histogram[float64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[float64]{ @@ -79,8 +79,8 @@ func assertStatsHandlerServerMetrics(t *testing.T, reader metric.Reader, service Attributes: attribute.NewSet( semconv.RPCMethod(name), semconv.RPCService(serviceName), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(code)), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeKey.Int64(int64(code)), testMetricAttr, ), }, @@ -88,9 +88,9 @@ func assertStatsHandlerServerMetrics(t *testing.T, reader metric.Reader, service }, }, { - Name: "rpc.server.requests_per_rpc", - Description: "Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs.", - Unit: "{count}", + Name: string(semconv.RPCServerRequestsPerRPCName), + Description: string(semconv.RPCServerRequestsPerRPCDescription), + Unit: string(semconv.RPCServerRequestsPerRPCUnit), Data: metricdata.Histogram[int64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[int64]{ @@ -98,8 +98,8 @@ func assertStatsHandlerServerMetrics(t *testing.T, reader metric.Reader, service Attributes: attribute.NewSet( semconv.RPCMethod(name), semconv.RPCService(serviceName), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(code)), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeKey.Int64(int64(code)), testMetricAttr, ), }, @@ -107,9 +107,9 @@ func assertStatsHandlerServerMetrics(t *testing.T, reader metric.Reader, service }, }, { - Name: "rpc.server.responses_per_rpc", - Description: "Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs.", - Unit: "{count}", + Name: string(semconv.RPCServerResponsesPerRPCName), + Description: string(semconv.RPCServerResponsesPerRPCDescription), + Unit: string(semconv.RPCServerResponsesPerRPCUnit), Data: metricdata.Histogram[int64]{ Temporality: metricdata.CumulativeTemporality, DataPoints: []metricdata.HistogramDataPoint[int64]{ @@ -117,8 +117,8 @@ func assertStatsHandlerServerMetrics(t *testing.T, reader metric.Reader, service Attributes: attribute.NewSet( semconv.RPCMethod(name), semconv.RPCService(serviceName), - otelgrpc.RPCSystemGRPC, - otelgrpc.GRPCStatusCodeKey.Int64(int64(code)), + semconv.RPCSystemGRPC, + semconv.RPCGRPCStatusCodeKey.Int64(int64(code)), testMetricAttr, ), },