Activities for Http Connections, Dns, Sockets and SslStream

src/libraries/Common/tests/System/Net/ActivityRecorder.cs

@@ -0,0 +1,136 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using Xunit;
+
+namespace System.Net.Test.Common
+{
+    internal class ActivityRecorder : IDisposable
+    {
+        private string _activitySourceName;
+        private string _activityName;
+
+        private readonly ActivityListener _listener;
+        private List<Activity> _finishedActivities = new();
+
+        public Predicate<Activity> Filter { get; set; } = _ => true;
+        public bool VerifyParent { get; set; } = true;
+        public Activity ExpectedParent { get; set; }
+
+        public int Started { get; private set; }
+        public int Stopped { get; private set; }
+        public Activity LastStartedActivity { get; private set; }
+        public Activity LastFinishedActivity { get; private set; }
+        public IEnumerable<Activity> FinishedActivities => _finishedActivities;
+
+        public ActivityRecorder(string activitySourceName, string activityName)
+        {
+            _activitySourceName = activitySourceName;
+            _activityName = activityName;
+            _listener = new ActivityListener
+            {
+                ShouldListenTo = (activitySource) => activitySource.Name == _activitySourceName,
+                Sample = (ref ActivityCreationOptions<ActivityContext> options) => ActivitySamplingResult.AllData,
+                ActivityStarted = (activity) => {
+                    if (activity.OperationName == _activityName && Filter(activity))
+                    {
+                        if (VerifyParent)
+                        {
+                            Assert.Same(ExpectedParent, activity.Parent);
+                        }
+
+                        Started++;
+                        LastStartedActivity = activity;
+                    }
+                },
+                ActivityStopped = (activity) => {
+                    if (activity.OperationName == _activityName && Filter(activity))
+                    {
+                        if (VerifyParent)
+                        {
+                            Assert.Same(ExpectedParent, activity.Parent);
+                        }
+
+                        Stopped++;
+                        LastFinishedActivity = activity;
+                        _finishedActivities.Add(activity);
+                    }
+                }
+            };
+
+            ActivitySource.AddActivityListener(_listener);   
+        }
+
+        public void Dispose() => _listener.Dispose();
+
+        public void VerifyActivityRecorded(int times)
+        {
+            Assert.Equal(times, Started);
+            Assert.Equal(times, Stopped);
+        }
+
+        public Activity VerifyActivityRecordedOnce()
+        {
+            VerifyActivityRecorded(1);
+            return LastFinishedActivity;
+        }
+    }
+
+    internal static class ActivityAssert
+    {
+        public static KeyValuePair<string, object> HasTag(Activity activity, string name)
+        {
+            KeyValuePair<string, object> tag = activity.TagObjects.SingleOrDefault(t => t.Key == name);
+            if (tag.Key is null)
+            {
+                Assert.Fail($"The Activity tags should contain {name}.");
+            }
+            return tag;
+        }
+
+        public static void HasTag<T>(Activity activity, string name, T expectedValue)
+        {
+            KeyValuePair<string, object> tag = HasTag(activity, name);
+            Assert.Equal(expectedValue, (T)tag.Value);
+        }
+
+        public static void HasTag<T>(Activity activity, string name, Func<T, bool> verifyValue)
+        {
+            T? value = (T?)activity.TagObjects.SingleOrDefault(t => t.Key == name).Value;
+            Assert.False(value is null, $"The Activity tags should contain {name}.");
+            Assert.True(verifyValue(value));
+        }
+
+        public static void HasNoTag(Activity activity, string name)
+        {
+            bool contains = activity.TagObjects.Any(t => t.Key == name);
+            Assert.False(contains, $"The Activity tags should not contain {name}.");
+        }
+
+        public static void FinishedInOrder(Activity first, Activity second)
+        {
+            Assert.True(first.StartTimeUtc + first.Duration < second.StartTimeUtc + second.Duration, $"{first.OperationName} should stop before {second.OperationName}");
+        }
+
+        public static string CamelToSnake(string camel)
+        {
+            if (string.IsNullOrEmpty(camel)) return camel;
+            StringBuilder bld = new();
+            bld.Append(char.ToLower(camel[0]));
+            for (int i = 1; i < camel.Length; i++)
+            {
+                char c = camel[i];
+                if (char.IsUpper(c))
+                {
+                    bld.Append('_');
+                }
+                bld.Append(char.ToLower(c));
+            }
+            return bld.ToString();
+        }
+    }
+}

src/libraries/System.Net.Http/src/System.Net.Http.csproj

@@ -37,6 +37,7 @@
     <Compile Include="System\Net\Http\ClientCertificateOption.cs" />
     <Compile Include="System\Net\Http\DelegatingHandler.cs" />
     <Compile Include="System\Net\Http\DiagnosticsHandler.cs" />
+    <Compile Include="System\Net\Http\DiagnosticsHelper.cs" />
     <Compile Include="System\Net\Http\DiagnosticsHandlerLoggingStrings.cs" />
     <Compile Include="System\Net\Http\EmptyContent.cs" />
     <Compile Include="System\Net\Http\EmptyReadStream.cs" />
@@ -174,6 +175,7 @@
     <Compile Include="System\Net\Http\Headers\AltSvcHeaderParser.cs" />
     <Compile Include="System\Net\Http\Headers\AltSvcHeaderValue.cs" />
     <Compile Include="System\Net\Http\Headers\KnownHeader.Http2And3.cs" />
+    <Compile Include="System\Net\Http\SocketsHttpHandler\ConnectionPool\ConnectionSetupDiagnostics.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http1.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http2.cs" />

src/libraries/System.Net.Http/src/System/Net/Http/DiagnosticsHandler.cs

@@ -16,7 +16,7 @@ namespace System.Net.Http
     internal sealed class DiagnosticsHandler : HttpMessageHandlerStage
     {
         private static readonly DiagnosticListener s_diagnosticListener = new DiagnosticListener(DiagnosticsHandlerLoggingStrings.DiagnosticListenerName);
-        private static readonly ActivitySource s_activitySource = new ActivitySource(DiagnosticsHandlerLoggingStrings.Namespace);
+        private static readonly ActivitySource s_activitySource = new ActivitySource(DiagnosticsHandlerLoggingStrings.RequestNamespace);
 
         private readonly HttpMessageHandler _innerHandler;
         private readonly DistributedContextPropagator _propagator;
@@ -58,14 +58,14 @@ private static bool IsEnabled()
             Activity? activity = null;
             if (s_activitySource.HasListeners())
             {
-                activity = s_activitySource.CreateActivity(DiagnosticsHandlerLoggingStrings.ActivityName, ActivityKind.Client);
+                activity = s_activitySource.CreateActivity(DiagnosticsHandlerLoggingStrings.RequestActivityName, ActivityKind.Client);
             }
 
             if (activity is null)
             {
-                if (Activity.Current is not null || s_diagnosticListener.IsEnabled(DiagnosticsHandlerLoggingStrings.ActivityName, requestMessage))
+                if (Activity.Current is not null || s_diagnosticListener.IsEnabled(DiagnosticsHandlerLoggingStrings.RequestActivityName, requestMessage))
                 {
-                    activity = new Activity(DiagnosticsHandlerLoggingStrings.ActivityName);
+                    activity = new Activity(DiagnosticsHandlerLoggingStrings.RequestActivityName);
                 }
             }
 
@@ -117,9 +117,9 @@ private async ValueTask<HttpResponseMessage> SendAsyncCore(HttpRequestMessage re
                 activity.Start();
 
                 // Only send start event to users who subscribed for it.
-                if (diagnosticListener.IsEnabled(DiagnosticsHandlerLoggingStrings.ActivityStartName))
+                if (diagnosticListener.IsEnabled(DiagnosticsHandlerLoggingStrings.RequestActivityStartName))
                 {
-                    Write(diagnosticListener, DiagnosticsHandlerLoggingStrings.ActivityStartName, new ActivityStartData(request));
+                    Write(diagnosticListener, DiagnosticsHandlerLoggingStrings.RequestActivityStartName, new ActivityStartData(request));
                 }
             }
 
@@ -177,9 +177,9 @@ await _innerHandler.SendAsync(request, cancellationToken).ConfigureAwait(false)
                     activity.SetEndTime(DateTime.UtcNow);
 
                     // Only send stop event to users who subscribed for it.
-                    if (diagnosticListener.IsEnabled(DiagnosticsHandlerLoggingStrings.ActivityStopName))
+                    if (diagnosticListener.IsEnabled(DiagnosticsHandlerLoggingStrings.RequestActivityStopName))
                     {
-                        Write(diagnosticListener, DiagnosticsHandlerLoggingStrings.ActivityStopName, new ActivityStopData(response, request, taskStatus));
+                        Write(diagnosticListener, DiagnosticsHandlerLoggingStrings.RequestActivityStopName, new ActivityStopData(response, request, taskStatus));
                     }
 
                     activity.Stop();

src/libraries/System.Net.Http/src/System/Net/Http/DiagnosticsHandlerLoggingStrings.cs

@@ -9,12 +9,17 @@ namespace System.Net.Http
     internal static class DiagnosticsHandlerLoggingStrings
     {
         public const string DiagnosticListenerName         = "HttpHandlerDiagnosticListener";
-        public const string Namespace                      = "System.Net.Http";
-        public const string RequestWriteNameDeprecated     = Namespace + ".Request";
-        public const string ResponseWriteNameDeprecated    = Namespace + ".Response";
-        public const string ExceptionEventName             = Namespace + ".Exception";
-        public const string ActivityName                   = Namespace + ".HttpRequestOut";
-        public const string ActivityStartName              = ActivityName + ".Start";
-        public const string ActivityStopName               = ActivityName + ".Stop";
+        public const string RequestNamespace               = "System.Net.Http";
+        public const string RequestWriteNameDeprecated     = RequestNamespace + ".Request";
+        public const string ResponseWriteNameDeprecated    = RequestNamespace + ".Response";
+        public const string ExceptionEventName             = RequestNamespace + ".Exception";
+        public const string RequestActivityName            = RequestNamespace + ".HttpRequestOut";
+        public const string RequestActivityStartName       = RequestActivityName + ".Start";
+        public const string RequestActivityStopName        = RequestActivityName + ".Stop";
+
+        public const string ConnectionNamespace            = "System.Net.Http.Connections";
+        public const string ConnectionSetupActivityName    = ConnectionNamespace + ".ConnectionSetup";
+        public const string WaitForConnectionNamespace     = "System.Net.Http.ConnectionLink";
+        public const string WaitForConnectionActivityName  = WaitForConnectionNamespace + ".WaitForConnection";
     }
 }

src/libraries/System.Net.Http/src/System/Net/Http/DiagnosticsHelper.cs

@@ -0,0 +1,80 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+
+namespace System.Net.Http
+{
+    internal static class DiagnosticsHelper
+    {
+        public static bool TryGetErrorType(HttpResponseMessage? response, Exception? exception, out string? errorType)
+        {
+            if (response is not null)
+            {
+                int statusCode = (int)response.StatusCode;
+
+                // In case the status code indicates a client or a server error, return the string representation of the status code.
+                // See the paragraph Status and the definition of 'error.type' in
+                // https://github.com/open-telemetry/semantic-conventions/blob/2bad9afad58fbd6b33cc683d1ad1f006e35e4a5d/docs/http/http-spans.md
+                if (statusCode >= 400 && statusCode <= 599)
+                {
+                    errorType = GetErrorStatusCodeString(statusCode);
+                    return true;
+                }
+            }
+
+            if (exception is null)
+            {
+                errorType = null;
+                return false;
+            }
+
+            Debug.Assert(Enum.GetValues<HttpRequestError>().Length == 12, "We need to extend the mapping in case new values are added to HttpRequestError.");
+            errorType = (exception as HttpRequestException)?.HttpRequestError switch
+            {
+                HttpRequestError.NameResolutionError => "name_resolution_error",
+                HttpRequestError.ConnectionError => "connection_error",
+                HttpRequestError.SecureConnectionError => "secure_connection_error",
+                HttpRequestError.HttpProtocolError => "http_protocol_error",
+                HttpRequestError.ExtendedConnectNotSupported => "extended_connect_not_supported",
+                HttpRequestError.VersionNegotiationError => "version_negotiation_error",
+                HttpRequestError.UserAuthenticationError => "user_authentication_error",
+                HttpRequestError.ProxyTunnelError => "proxy_tunnel_error",
+                HttpRequestError.InvalidResponse => "invalid_response",
+                HttpRequestError.ResponseEnded => "response_ended",
+                HttpRequestError.ConfigurationLimitExceeded => "configuration_limit_exceeded",
+
+                // Fall back to the exception type name in case of HttpRequestError.Unknown or when exception is not an HttpRequestException.
+                _ => exception.GetType().FullName!
+            };
+            return true;
+        }
+
+        private static object[]? s_boxedStatusCodes;
+        private static string[]? s_statusCodeStrings;
+
+#pragma warning disable CA1859 // we explictly box here
+        public static object GetBoxedStatusCode(int statusCode)
+        {
+            object[] boxes = LazyInitializer.EnsureInitialized(ref s_boxedStatusCodes, static () => new object[512]);
+
+            return (uint)statusCode < (uint)boxes.Length
+                ? boxes[statusCode] ??= statusCode
+                : statusCode;
+        }
+#pragma warning restore
+
+        private static string GetErrorStatusCodeString(int statusCode)
+        {
+            Debug.Assert(statusCode >= 400 && statusCode <= 599);
+
+            string[] strings = LazyInitializer.EnsureInitialized(ref s_statusCodeStrings, static () => new string[200]);
+            int index = statusCode - 400;
+            return (uint)index < (uint)strings.Length
+                ? strings[index] ??= statusCode.ToString()
+                : statusCode.ToString();
+        }
+    }
+}