Activities for Http Connections, Dns, Sockets and SslStream

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

@@ -0,0 +1,74 @@
+// 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.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using Xunit;
+
+namespace System.Net.Test.Common
+{
+    internal class ActivityRecorder : IDisposable
+    {
+        private string _activitySourceName;
+        private string _activityName;
+
+        private readonly ActivityListener _listener;
+
+        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 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;
+                    }
+                }
+            };
+
+            ActivitySource.AddActivityListener(_listener);   
+        }
+
+        public void Dispose() => _listener.Dispose();
+
+        public void VerifyActivityRecorded(int times)
+        {
+            Assert.Equal(times, Started);
+            Assert.Equal(times, Stopped);
+        }
+    }
+}

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,15 @@ 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 ConnectionActivityName         = ConnectionNamespace + ".HttpConnection";
     }
 }

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ConnectHelper.cs

@@ -55,7 +55,7 @@ private static SslClientAuthenticationOptions SetUpRemoteCertificateValidationCa
             return sslOptions;
         }
 
-        public static async ValueTask<SslStream> EstablishSslConnectionAsync(SslClientAuthenticationOptions sslOptions, HttpRequestMessage request, bool async, Stream stream, CancellationToken cancellationToken)
+        public static async ValueTask<SslStream> EstablishSslConnectionAsync(SslClientAuthenticationOptions sslOptions, HttpRequestMessage request, bool async, Stream stream, Activity? activity, CancellationToken cancellationToken)
         {
             sslOptions = SetUpRemoteCertificateValidationCallback(sslOptions, request);
 
@@ -78,6 +78,7 @@ public static async ValueTask<SslStream> EstablishSslConnectionAsync(SslClientAu
             catch (Exception e)
             {
                 sslStream.Dispose();
+                activity?.Stop();
 
                 if (e is OperationCanceledException)
                 {

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ConnectionPool/HttpConnectionPool.Http1.cs

@@ -294,14 +294,14 @@ private async Task InjectNewHttp11ConnectionAsync(RequestQueue<HttpConnection>.Q
 
         internal async ValueTask<HttpConnection> CreateHttp11ConnectionAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)
         {
-            (Stream stream, TransportContext? transportContext, IPEndPoint? remoteEndPoint) = await ConnectAsync(request, async, cancellationToken).ConfigureAwait(false);
-            return await ConstructHttp11ConnectionAsync(async, stream, transportContext, request, remoteEndPoint, cancellationToken).ConfigureAwait(false);
+            (Stream stream, TransportContext? transportContext, Activity? activity,  IPEndPoint? remoteEndPoint) = await ConnectAsync(request, async, cancellationToken).ConfigureAwait(false);
+            return await ConstructHttp11ConnectionAsync(async, stream, transportContext, request, activity, remoteEndPoint, cancellationToken).ConfigureAwait(false);
         }
 
-        private async ValueTask<HttpConnection> ConstructHttp11ConnectionAsync(bool async, Stream stream, TransportContext? transportContext, HttpRequestMessage request, IPEndPoint? remoteEndPoint, CancellationToken cancellationToken)
+        private async ValueTask<HttpConnection> ConstructHttp11ConnectionAsync(bool async, Stream stream, TransportContext? transportContext, HttpRequestMessage request, Activity? activity, IPEndPoint? remoteEndPoint, CancellationToken cancellationToken)
         {
             Stream newStream = await ApplyPlaintextFilterAsync(async, stream, HttpVersion.Version11, request, cancellationToken).ConfigureAwait(false);
-            return new HttpConnection(this, newStream, transportContext, remoteEndPoint);
+            return new HttpConnection(this, newStream, transportContext, activity, remoteEndPoint);
         }
 
         private void HandleHttp11ConnectionFailure(HttpConnectionWaiter<HttpConnection>? requestWaiter, Exception e)

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ConnectionPool/HttpConnectionPool.Http2.cs

@@ -185,7 +185,7 @@ private async Task InjectNewHttp2ConnectionAsync(RequestQueue<Http2Connection?>.
             waiter.ConnectionCancellationTokenSource = cts;
             try
             {
-                (Stream stream, TransportContext? transportContext, IPEndPoint? remoteEndPoint) = await ConnectAsync(queueItem.Request, true, cts.Token).ConfigureAwait(false);
+                (Stream stream, TransportContext? transportContext, Activity? activity, IPEndPoint? remoteEndPoint) = await ConnectAsync(queueItem.Request, true, cts.Token).ConfigureAwait(false);
 
                 if (IsSecure)
                 {
@@ -202,19 +202,19 @@ private async Task InjectNewHttp2ConnectionAsync(RequestQueue<Http2Connection?>.
                         }
                         else
                         {
-                            connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, remoteEndPoint, cts.Token).ConfigureAwait(false);
+                            connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, activity, remoteEndPoint, cts.Token).ConfigureAwait(false);
                         }
                     }
                     else
                     {
                         // We established an SSL connection, but the server denied our request for HTTP2.
-                        await HandleHttp11Downgrade(queueItem.Request, stream, transportContext, remoteEndPoint, cts.Token).ConfigureAwait(false);
+                        await HandleHttp11Downgrade(queueItem.Request, stream, transportContext, activity, remoteEndPoint, cts.Token).ConfigureAwait(false);
                         return;
                     }
                 }
                 else
                 {
-                    connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, remoteEndPoint, cts.Token).ConfigureAwait(false);
+                    connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, activity, remoteEndPoint, cts.Token).ConfigureAwait(false);
                 }
             }
             catch (Exception e)
@@ -244,11 +244,11 @@ private async Task InjectNewHttp2ConnectionAsync(RequestQueue<Http2Connection?>.
             }
         }
 
-        private async ValueTask<Http2Connection> ConstructHttp2ConnectionAsync(Stream stream, HttpRequestMessage request, IPEndPoint? remoteEndPoint, CancellationToken cancellationToken)
+        private async ValueTask<Http2Connection> ConstructHttp2ConnectionAsync(Stream stream, HttpRequestMessage request, Activity? activity, IPEndPoint? remoteEndPoint, CancellationToken cancellationToken)
         {
             stream = await ApplyPlaintextFilterAsync(async: true, stream, HttpVersion.Version20, request, cancellationToken).ConfigureAwait(false);
 
-            Http2Connection http2Connection = new Http2Connection(this, stream, remoteEndPoint);
+            Http2Connection http2Connection = new Http2Connection(this, stream, activity, remoteEndPoint);
             try
             {
                 await http2Connection.SetupAsync(cancellationToken).ConfigureAwait(false);
@@ -287,7 +287,7 @@ private void HandleHttp2ConnectionFailure(HttpConnectionWaiter<Http2Connection?>
             }
         }
 
-        private async Task HandleHttp11Downgrade(HttpRequestMessage request, Stream stream, TransportContext? transportContext, IPEndPoint? remoteEndPoint, CancellationToken cancellationToken)
+        private async Task HandleHttp11Downgrade(HttpRequestMessage request, Stream stream, TransportContext? transportContext, Activity? activity, IPEndPoint? remoteEndPoint, CancellationToken cancellationToken)
         {
             if (NetEventSource.Log.IsEnabled()) Trace("Server does not support HTTP2; disabling HTTP2 use and proceeding with HTTP/1.1 connection");
 
@@ -345,7 +345,7 @@ private async Task HandleHttp11Downgrade(HttpRequestMessage request, Stream stre
             try
             {
                 // Note, the same CancellationToken from the original HTTP2 connection establishment still applies here.
-                http11Connection = await ConstructHttp11ConnectionAsync(true, stream, transportContext, request, remoteEndPoint, cancellationToken).ConfigureAwait(false);
+                http11Connection = await ConstructHttp11ConnectionAsync(true, stream, transportContext, request, activity, remoteEndPoint, cancellationToken).ConfigureAwait(false);
             }
             catch (OperationCanceledException oce) when (oce.CancellationToken == cancellationToken)
             {