update HttpSemanticConventions for Instrumentation.AspNetCore

src/OpenTelemetry.Api/Internal/SemanticConventions.cs

@@ -110,5 +110,17 @@ internal static class SemanticConventions
         public const string AttributeExceptionType = "exception.type";
         public const string AttributeExceptionMessage = "exception.message";
         public const string AttributeExceptionStacktrace = "exception.stacktrace";
+
+        // Http v1.21.0 https://github.com/open-telemetry/opentelemetry-specification/blob/v1.21.0/specification/trace/semantic_conventions/http.md
+        public const string AttributeClientSocketPort = "client.socket.port"; // replaces: "net.peer.port" (AttributeNetPeerPort)
+        public const string AttributeHttpRequestMethod = "http.request.method"; // replaces: "http.method" (AttributeHttpMethod)
+        public const string AttributeHttpResponseStatusCode = "http.response.status_code"; // replaces: "http.status_code" (AttributeHttpStatusCode)
+        public const string AttributeNetworkProtocolVersion = "network.protocol.version"; // replaces: "http.flavor" (AttributeHttpFlavor)
+        public const string AttributeServerAddress = "server.address"; // replaces: "net.host.name" (AttributeNetHostName)
+        public const string AttributeServerPort = "server.port"; // replaces: "net.host.port" (AttributeNetHostPort)
+        public const string AttributeUrlPath = "url.path"; // replaces: "http.target" (AttributeHttpTarget)
+        public const string AttributeUrlScheme = "url.scheme"; // replaces: "http.scheme" (AttributeHttpScheme)
+        public const string AttributeUrlQuery = "url.query";
+        public const string AttributeUserAgentOriginal = "user_agent.original"; // replaces: "http.user_agent" (AttributeHttpUserAgent)
     }
 }

src/OpenTelemetry.Instrumentation.AspNetCore/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+* Updated [Http Semantic Conventions](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.21.0/specification/trace/semantic_conventions/http.md).
+  * This library can emit either old, new, or both attributes. Users can control
+  which attributes are emitted by setting the environment variable
+  `OTEL_SEMCONV_STABILITY_OPT_IN`.
+
 ## 1.5.0-beta.1
 
 Released 2023-Jun-05

src/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpInListener.cs

@@ -197,29 +197,66 @@ public void OnStartActivity(Activity activity, object payload)
                 var path = (request.PathBase.HasValue || request.Path.HasValue) ? (request.PathBase + request.Path).ToString() : "/";
                 activity.DisplayName = path;
 
-                // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md
-                if (request.Host.HasValue)
+                // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/trace/semantic_conventions/http.md
+                if (this.httpSemanticConvention.HasFlag(HttpSemanticConvention.Old))
                 {
-                    activity.SetTag(SemanticConventions.AttributeNetHostName, request.Host.Host);
+                    if (request.Host.HasValue)
+                    {
+                        activity.SetTag(SemanticConventions.AttributeNetHostName, request.Host.Host);
+
+                        if (request.Host.Port is not null && request.Host.Port != 80 && request.Host.Port != 443)
+                        {
+                            activity.SetTag(SemanticConventions.AttributeNetHostPort, request.Host.Port);
+                        }
+                    }
 
-                    if (request.Host.Port is not null && request.Host.Port != 80 && request.Host.Port != 443)
+                    activity.SetTag(SemanticConventions.AttributeHttpMethod, request.Method);
+                    activity.SetTag(SemanticConventions.AttributeHttpScheme, request.Scheme);
+                    activity.SetTag(SemanticConventions.AttributeHttpTarget, path);
+                    activity.SetTag(SemanticConventions.AttributeHttpUrl, GetUri(request));
+                    activity.SetTag(SemanticConventions.AttributeHttpFlavor, HttpTagHelper.GetFlavorTagValueFromProtocol(request.Protocol));
+
+                    if (request.Headers.TryGetValue("User-Agent", out var values))
                     {
-                        activity.SetTag(SemanticConventions.AttributeNetHostPort, request.Host.Port);
+                        var userAgent = values.Count > 0 ? values[0] : null;
+                        if (!string.IsNullOrEmpty(userAgent))
+                        {
+                            activity.SetTag(SemanticConventions.AttributeHttpUserAgent, userAgent);
+                        }
                     }
                 }
 
-                activity.SetTag(SemanticConventions.AttributeHttpMethod, request.Method);
-                activity.SetTag(SemanticConventions.AttributeHttpScheme, request.Scheme);
-                activity.SetTag(SemanticConventions.AttributeHttpTarget, path);
-                activity.SetTag(SemanticConventions.AttributeHttpUrl, GetUri(request));
-                activity.SetTag(SemanticConventions.AttributeHttpFlavor, HttpTagHelper.GetFlavorTagValueFromProtocol(request.Protocol));
-
-                if (request.Headers.TryGetValue("User-Agent", out var values))
+                // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/v1.21.0/specification/trace/semantic_conventions/http.md
+                if (this.httpSemanticConvention.HasFlag(HttpSemanticConvention.New))
                 {
-                    var userAgent = values.Count > 0 ? values[0] : null;
-                    if (!string.IsNullOrEmpty(userAgent))
+                    if (request.Host.HasValue)
+                    {
+                        activity.SetTag(SemanticConventions.AttributeServerAddress, request.Host.Host);
+
+                        if (request.Host.Port is not null && request.Host.Port != 80 && request.Host.Port != 443)
+                        {
+                            activity.SetTag(SemanticConventions.AttributeServerPort, request.Host.Port);
+                        }
+                    }
+
+                    if (request.QueryString.HasValue)
                     {
-                        activity.SetTag(SemanticConventions.AttributeHttpUserAgent, userAgent);
+                        // QueryString should be sanitized. see: https://github.com/open-telemetry/opentelemetry-dotnet/issues/4571
+                        activity.SetTag(SemanticConventions.AttributeUrlQuery, request.QueryString.Value);
+                    }
+
+                    activity.SetTag(SemanticConventions.AttributeHttpRequestMethod, request.Method);
+                    activity.SetTag(SemanticConventions.AttributeUrlScheme, request.Scheme);
+                    activity.SetTag(SemanticConventions.AttributeUrlPath, path);
+                    activity.SetTag(SemanticConventions.AttributeNetworkProtocolVersion, HttpTagHelper.GetFlavorTagValueFromProtocol(request.Protocol));
+
+                    if (request.Headers.TryGetValue("User-Agent", out var values))
+                    {
+                        var userAgent = values.Count > 0 ? values[0] : null;
+                        if (!string.IsNullOrEmpty(userAgent))
+                        {
+                            activity.SetTag(SemanticConventions.AttributeUserAgentOriginal, userAgent);
+                        }
                     }
                 }
 
@@ -247,12 +284,20 @@ public void OnStopActivity(Activity activity, object payload)
 
                 var response = context.Response;
 
-                activity.SetTag(SemanticConventions.AttributeHttpStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode));
+                if (this.httpSemanticConvention.HasFlag(HttpSemanticConvention.Old))
+                {
+                    activity.SetTag(SemanticConventions.AttributeHttpStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode));
+                }
+
+                if (this.httpSemanticConvention.HasFlag(HttpSemanticConvention.New))
+                {
+                    activity.SetTag(SemanticConventions.AttributeHttpResponseStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode));
+                }
 
 #if !NETSTANDARD2_0
                 if (this.options.EnableGrpcAspNetCoreSupport && TryGetGrpcMethod(activity, out var grpcMethod))
                 {
-                    AddGrpcAttributes(activity, grpcMethod, context);
+                    this.AddGrpcAttributes(activity, grpcMethod, context);
                 }
                 else if (activity.Status == ActivityStatusCode.Unset)
                 {
@@ -429,7 +474,7 @@ private static bool TryGetGrpcMethod(Activity activity, out string grpcMethod)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void AddGrpcAttributes(Activity activity, string grpcMethod, HttpContext context)
+        private void AddGrpcAttributes(Activity activity, string grpcMethod, HttpContext context)
         {
             // The RPC semantic conventions indicate the span name
             // should not have a leading forward slash.
@@ -439,10 +484,19 @@ private static void AddGrpcAttributes(Activity activity, string grpcMethod, Http
             activity.SetTag(SemanticConventions.AttributeRpcSystem, GrpcTagHelper.RpcSystemGrpc);
             if (context.Connection.RemoteIpAddress != null)
             {
+                // TODO: This attribute was changed in v1.13.0 https://github.com/open-telemetry/opentelemetry-specification/pull/2614
                 activity.SetTag(SemanticConventions.AttributeNetPeerIp, context.Connection.RemoteIpAddress.ToString());
             }
 
-            activity.SetTag(SemanticConventions.AttributeNetPeerPort, context.Connection.RemotePort);
+            if (this.httpSemanticConvention.HasFlag(HttpSemanticConvention.Old))
+            {
+                activity.SetTag(SemanticConventions.AttributeNetPeerPort, context.Connection.RemotePort);
+            }
+
+            if (this.httpSemanticConvention.HasFlag(HttpSemanticConvention.New))
+            {
+                activity.SetTag(SemanticConventions.AttributeServerPort, context.Connection.RemotePort);
+            }
 
             bool validConversion = GrpcTagHelper.TryGetGrpcStatusCodeFromActivity(activity, out int status);
             if (validConversion)

src/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpInMetricsListener.cs

@@ -82,20 +82,44 @@ public override void OnEventWritten(string name, object payload)
 
                 TagList tags = default;
 
-                tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeHttpFlavor, HttpTagHelper.GetFlavorTagValueFromProtocol(context.Request.Protocol)));
-                tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeHttpScheme, context.Request.Scheme));
-                tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeHttpMethod, context.Request.Method));
-                tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeHttpStatusCode, TelemetryHelper.GetBoxedStatusCode(context.Response.StatusCode)));
+                // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/trace/semantic_conventions/http.md
+                if (this.httpSemanticConvention.HasFlag(HttpSemanticConvention.Old))
+                {
+                    tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeHttpFlavor, HttpTagHelper.GetFlavorTagValueFromProtocol(context.Request.Protocol)));
+                    tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeHttpScheme, context.Request.Scheme));
+                    tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeHttpMethod, context.Request.Method));
+                    tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeHttpStatusCode, TelemetryHelper.GetBoxedStatusCode(context.Response.StatusCode)));
+
+                    if (context.Request.Host.HasValue)
+                    {
+                        tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeNetHostName, context.Request.Host.Host));
+
+                        if (context.Request.Host.Port is not null && context.Request.Host.Port != 80 && context.Request.Host.Port != 443)
+                        {
+                            tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeNetHostPort, context.Request.Host.Port));
+                        }
+                    }
+                }
 
-                if (context.Request.Host.HasValue)
+                // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/v1.21.0/specification/trace/semantic_conventions/http.md
+                if (this.httpSemanticConvention.HasFlag(HttpSemanticConvention.New))
                 {
-                    tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeNetHostName, context.Request.Host.Host));
+                    tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeNetworkProtocolVersion, HttpTagHelper.GetFlavorTagValueFromProtocol(context.Request.Protocol)));
+                    tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeUrlScheme, context.Request.Scheme));
+                    tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeHttpRequestMethod, context.Request.Method));
+                    tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeHttpResponseStatusCode, TelemetryHelper.GetBoxedStatusCode(context.Response.StatusCode)));
 
-                    if (context.Request.Host.Port is not null && context.Request.Host.Port != 80 && context.Request.Host.Port != 443)
+                    if (context.Request.Host.HasValue)
                     {
-                        tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeNetHostPort, context.Request.Host.Port));
+                        tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeServerAddress, context.Request.Host.Host));
+
+                        if (context.Request.Host.Port is not null && context.Request.Host.Port != 80 && context.Request.Host.Port != 443)
+                        {
+                            tags.Add(new KeyValuePair<string, object>(SemanticConventions.AttributeServerPort, context.Request.Host.Port));
+                        }
                     }
                 }
+
 #if NET6_0_OR_GREATER
                 var route = (context.GetEndpoint() as RouteEndpoint)?.RoutePattern.RawText;
                 if (!string.IsNullOrEmpty(route))