[release/8.0] Adjust System.Net metrics for OTel conformance and consistency (#93414)

antonfirsov · web-flow · commit 60b77a63df30 · 2023-10-13T17:35:38.000-06:00
* Rename `server.socket.address` to `network.peer.address` (#93255) * Report Exception.FullName for http.client.request.duration/error.type (#93322) * Adjust the DNS lookup duration metric (#93254)
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Metrics/MetricsHandler.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Metrics/MetricsHandler.cs
@@ -169,7 +169,7 @@ private static bool TryGetErrorType(HttpResponseMessage? response, Exception? ex
                 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().Name
+                _ => exception.GetType().FullName!
             };
             return true;
         }
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Metrics/ConnectionMetrics.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Metrics/ConnectionMetrics.cs
@@ -14,18 +14,18 @@ internal sealed class ConnectionMetrics
         private readonly object _schemeTag;
         private readonly object _hostTag;
         private readonly object? _portTag;
-        private readonly object? _socketAddressTag;
+        private readonly object? _peerAddressTag;
         private bool _currentlyIdle;
 
-        public ConnectionMetrics(SocketsHttpHandlerMetrics metrics, string protocolVersion, string scheme, string host, int? port, string? socketAddress)
+        public ConnectionMetrics(SocketsHttpHandlerMetrics metrics, string protocolVersion, string scheme, string host, int? port, string? peerAddress)
         {
             _metrics = metrics;
             _openConnectionsEnabled = _metrics.OpenConnections.Enabled;
             _protocolVersionTag = protocolVersion;
             _schemeTag = scheme;
             _hostTag = host;
             _portTag = port;
-            _socketAddressTag = socketAddress;
+            _peerAddressTag = peerAddress;
         }
 
         // TagList is a huge struct, so we avoid storing it in a field to reduce the amount we allocate on the heap.
@@ -42,9 +42,9 @@ private TagList GetTags()
                 tags.Add("server.port", _portTag);
             }
 
-            if (_socketAddressTag is not null)
+            if (_peerAddressTag is not null)
             {
-                tags.Add("server.socket.address", _socketAddressTag);
+                tags.Add("network.peer.address", _peerAddressTag);
             }
 
             return tags;
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/MetricsTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/MetricsTest.cs
@@ -47,9 +47,9 @@ protected static void VerifyTag<T>(KeyValuePair<string, object?>[] tags, string
             }
         }
 
-        private static void VerifySocketAddress(KeyValuePair<string, object?>[] tags)
+        private static void VerifyPeerAddress(KeyValuePair<string, object?>[] tags)
         {
-            string ipString = (string)tags.Single(t => t.Key == "server.socket.address").Value;
+            string ipString = (string)tags.Single(t => t.Key == "network.peer.address").Value;
             IPAddress ip = IPAddress.Parse(ipString);
             Assert.True(ip.Equals(IPAddress.Loopback.MapToIPv6()) ||
                     ip.Equals(IPAddress.Loopback) ||
@@ -122,7 +122,7 @@ protected static void VerifyOpenConnections(string actualName, object measuremen
             VerifySchemeHostPortTags(tags, uri);
             VerifyTag(tags, "network.protocol.version", GetVersionString(protocolVersion));
             VerifyTag(tags, "http.connection.state", state);
-            VerifySocketAddress(tags);
+            VerifyPeerAddress(tags);
         }
 
         protected static void VerifyConnectionDuration(string instrumentName, object measurement, KeyValuePair<string, object?>[] tags, Uri uri, Version? protocolVersion)
@@ -132,7 +132,7 @@ protected static void VerifyConnectionDuration(string instrumentName, object mea
             Assert.InRange(value, double.Epsilon, 60);
             VerifySchemeHostPortTags(tags, uri);
             VerifyTag(tags, "network.protocol.version", GetVersionString(protocolVersion));
-            VerifySocketAddress(tags);
+            VerifyPeerAddress(tags);
         }
 
         protected static void VerifyTimeInQueue(string instrumentName, object measurement, KeyValuePair<string, object?>[] tags, Uri uri, Version? protocolVersion, string method = "GET")
@@ -670,8 +670,8 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                 _output.WriteLine($"Client exception: {clientException}");
 
                 string[] expectedExceptionTypes = TestAsync
-                    ? [nameof(TaskCanceledException)]
-                    : [nameof(TaskCanceledException), nameof(OperationCanceledException)];
+                    ? [typeof(TaskCanceledException).FullName]
+                    : [typeof(TaskCanceledException).FullName, typeof(OperationCanceledException).FullName];
 
                 Measurement<double> m = Assert.Single(recorder.GetMeasurements());
                 VerifyRequestDuration(m, uri, acceptedErrorTypes: expectedExceptionTypes);
@@ -852,7 +852,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                 Assert.True(ex is HttpRequestException or TaskCanceledException);
 
                 Measurement<double> m = Assert.Single(recorder.GetMeasurements());
-                VerifyRequestDuration(m, uri, acceptedErrorTypes: [nameof(TaskCanceledException), "response_ended"]);
+                VerifyRequestDuration(m, uri, acceptedErrorTypes: [typeof(TaskCanceledException).FullName, "response_ended"]);
             }, async server =>
             {
                 try
diff --git a/src/libraries/System.Net.NameResolution/src/System/Net/Dns.cs b/src/libraries/System.Net.NameResolution/src/System/Net/Dns.cs
@@ -23,13 +23,13 @@ public static string GetHostName()
             {
                 name = NameResolutionPal.GetHostName();
             }
-            catch when (LogFailure(string.Empty, startingTimestamp))
+            catch (Exception ex) when (LogFailure(string.Empty, startingTimestamp, ex))
             {
                 Debug.Fail("LogFailure should return false");
                 throw;
             }
 
-            NameResolutionTelemetry.Log.AfterResolution(string.Empty, startingTimestamp, successful: true);
+            NameResolutionTelemetry.Log.AfterResolution(string.Empty, startingTimestamp);
 
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(null, name);
             return name;
@@ -394,13 +394,13 @@ private static object GetHostEntryOrAddressesCore(string hostName, bool justAddr
                         Aliases = aliases
                     };
             }
-            catch when (LogFailure(hostName, startingTimestamp))
+            catch (Exception ex) when (LogFailure(hostName, startingTimestamp, ex))
             {
                 Debug.Fail("LogFailure should return false");
                 throw;
             }
 
-            NameResolutionTelemetry.Log.AfterResolution(hostName, startingTimestamp, successful: true);
+            NameResolutionTelemetry.Log.AfterResolution(hostName, startingTimestamp);
 
             return result;
         }
@@ -434,13 +434,13 @@ private static object GetHostEntryOrAddressesCore(IPAddress address, bool justAd
                 }
                 Debug.Assert(name != null);
             }
-            catch when (LogFailure(address, startingTimestamp))
+            catch (Exception ex) when (LogFailure(address, startingTimestamp, ex))
             {
                 Debug.Fail("LogFailure should return false");
                 throw;
             }
 
-            NameResolutionTelemetry.Log.AfterResolution(address, startingTimestamp, successful: true);
+            NameResolutionTelemetry.Log.AfterResolution(address, startingTimestamp);
 
             // Do the forward lookup to get the IPs for that host name
             startingTimestamp = NameResolutionTelemetry.Log.BeforeResolution(name);
@@ -464,13 +464,13 @@ private static object GetHostEntryOrAddressesCore(IPAddress address, bool justAd
                         AddressList = addresses
                     };
             }
-            catch when (LogFailure(name, startingTimestamp))
+            catch (Exception ex) when (LogFailure(name, startingTimestamp, ex))
             {
                 Debug.Fail("LogFailure should return false");
                 throw;
             }
 
-            NameResolutionTelemetry.Log.AfterResolution(name, startingTimestamp, successful: true);
+            NameResolutionTelemetry.Log.AfterResolution(name, startingTimestamp);
 
             // One of three things happened:
             // 1. Success.
@@ -577,7 +577,7 @@ private static Task GetHostEntryOrAddressesCoreAsync(string hostName, bool justR
         }
 
         private static Task<T>? GetAddrInfoWithTelemetryAsync<T>(string hostName, bool justAddresses, AddressFamily addressFamily, CancellationToken cancellationToken)
-             where T : class
+            where T : class
         {
             long startingTimestamp = Stopwatch.GetTimestamp();
             Task? task = NameResolutionPal.GetAddrInfoAsync(hostName, justAddresses, addressFamily, cancellationToken);
@@ -594,15 +594,19 @@ private static Task GetHostEntryOrAddressesCoreAsync(string hostName, bool justR
             static async Task<T> CompleteAsync(Task task, string hostName, long startingTimestamp)
             {
                 _ = NameResolutionTelemetry.Log.BeforeResolution(hostName);
-                T? result = null;
+                Exception? exception = null;
                 try
                 {
-                    result = await ((Task<T>)task).ConfigureAwait(false);
-                    return result;
+                    return await ((Task<T>)task).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    exception = ex;
+                    throw;
                 }
                 finally
                 {
-                    NameResolutionTelemetry.Log.AfterResolution(hostName, startingTimestamp, successful: result is not null);
+                    NameResolutionTelemetry.Log.AfterResolution(hostName, startingTimestamp, exception);
                 }
             }
         }
@@ -627,9 +631,9 @@ private static void ValidateHostName(string hostName)
             }
         }
 
-        private static bool LogFailure(object hostNameOrAddress, long? startingTimestamp)
+        private static bool LogFailure(object hostNameOrAddress, long? startingTimestamp, Exception exception)
         {
-            NameResolutionTelemetry.Log.AfterResolution(hostNameOrAddress, startingTimestamp, successful: false);
+            NameResolutionTelemetry.Log.AfterResolution(hostNameOrAddress, startingTimestamp, exception);
             return false;
         }
 
diff --git a/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionMetrics.cs b/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionMetrics.cs
@@ -13,15 +13,35 @@ internal static class NameResolutionMetrics
         private static readonly Meter s_meter = new("System.Net.NameResolution");
 
         private static readonly Histogram<double> s_lookupDuration = s_meter.CreateHistogram<double>(
-            name: "dns.lookups.duration",
+            name: "dns.lookup.duration",
             unit: "s",
             description: "Measures the time taken to perform a DNS lookup.");
 
         public static bool IsEnabled() => s_lookupDuration.Enabled;
 
-        public static void AfterResolution(TimeSpan duration, string hostName)
+        public static void AfterResolution(TimeSpan duration, string hostName, Exception? exception)
         {
-            s_lookupDuration.Record(duration.TotalSeconds, KeyValuePair.Create("dns.question.name", (object?)hostName));
+            var hostNameTag = KeyValuePair.Create("dns.question.name", (object?)hostName);
+
+            if (exception is null)
+            {
+                s_lookupDuration.Record(duration.TotalSeconds, hostNameTag);
+            }
+            else
+            {
+                var errorTypeTag = KeyValuePair.Create("error.type", (object?)GetErrorType(exception));
+                s_lookupDuration.Record(duration.TotalSeconds, hostNameTag, errorTypeTag);
+            }
         }
+
+        private static string GetErrorType(Exception exception) => (exception as SocketException)?.SocketErrorCode switch
+        {
+            SocketError.HostNotFound => "host_not_found",
+            SocketError.TryAgain => "try_again",
+            SocketError.AddressFamilyNotSupported => "address_family_not_supported",
+            SocketError.NoRecovery => "no_recovery",
+
+            _ => exception.GetType().FullName!
+        };
     }
 }
diff --git a/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionTelemetry.cs b/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionTelemetry.cs
@@ -81,7 +81,7 @@ public long BeforeResolution(object hostNameOrAddress)
         }
 
         [NonEvent]
-        public void AfterResolution(object hostNameOrAddress, long? startingTimestamp, bool successful)
+        public void AfterResolution(object hostNameOrAddress, long? startingTimestamp, Exception? exception = null)
         {
             Debug.Assert(startingTimestamp.HasValue);
             if (startingTimestamp == 0)
@@ -99,7 +99,7 @@ public void AfterResolution(object hostNameOrAddress, long? startingTimestamp, b
 
                 if (IsEnabled(EventLevel.Informational, EventKeywords.None))
                 {
-                    if (!successful)
+                    if (exception is not null)
                     {
                         ResolutionFailed();
                     }
@@ -110,7 +110,7 @@ public void AfterResolution(object hostNameOrAddress, long? startingTimestamp, b
 
             if (NameResolutionMetrics.IsEnabled())
             {
-                NameResolutionMetrics.AfterResolution(duration, GetHostnameFromStateObject(hostNameOrAddress));
+                NameResolutionMetrics.AfterResolution(duration, GetHostnameFromStateObject(hostNameOrAddress), exception);
             }
         }
 
diff --git a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/MetricsTest.cs b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/MetricsTest.cs
@@ -14,7 +14,7 @@ namespace System.Net.NameResolution.Tests
 {
     public class MetricsTest
     {
-        private const string DnsLookupDuration = "dns.lookups.duration";
+        private const string DnsLookupDuration = "dns.lookup.duration";
 
         [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
         public static void ResolveValidHostName_MetricsRecorded()
@@ -57,17 +57,26 @@ public static async Task ResolveInvalidHostName_MetricsRecorded()
             Assert.ThrowsAny<SocketException>(() => Dns.EndGetHostEntry(Dns.BeginGetHostEntry(InvalidHostName, null, null)));
             Assert.ThrowsAny<SocketException>(() => Dns.EndGetHostAddresses(Dns.BeginGetHostAddresses(InvalidHostName, null, null)));
 
-            double[] measurements = GetMeasurementsForHostname(recorder, InvalidHostName);
+            double[] measurements = GetMeasurementsForHostname(recorder, InvalidHostName, "host_not_found");
 
             Assert.Equal(6, measurements.Length);
             Assert.All(measurements, m => Assert.True(m > double.Epsilon));
         }
 
-        private static double[] GetMeasurementsForHostname(InstrumentRecorder<double> recorder, string hostname)
+        private static double[] GetMeasurementsForHostname(InstrumentRecorder<double> recorder, string hostname, string? expectedErrorType = null)
         {
             return recorder
                 .GetMeasurements()
-                .Where(m => m.Tags.ToArray().Any(t => t.Key == "dns.question.name" && t.Value is string hostnameTag && hostnameTag == hostname))
+                .Where(m =>
+                {
+                    KeyValuePair<string, object?>[] tags = m.Tags.ToArray();
+                    if (!tags.Any(t => t.Key == "dns.question.name" && t.Value is string hostnameTag && hostnameTag == hostname))
+                    {
+                        return false;
+                    }
+                    string? actualErrorType = tags.FirstOrDefault(t => t.Key == "error.type").Value as string;
+                    return expectedErrorType == actualErrorType;
+                })
                 .Select(m => m.Value)
                 .ToArray();
         }

Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,7 @@ private static bool TryGetErrorType(HttpResponseMessage? response, Exception? ex`
`169`	`169`	`HttpRequestError.ConfigurationLimitExceeded => "configuration_limit_exceeded",`
`170`	`170`
`171`	`171`	`// Fall back to the exception type name in case of HttpRequestError.Unknown or when exception is not an HttpRequestException.`
`172`		`- _ => exception.GetType().Name`
	`172`	`+ _ => exception.GetType().FullName!`
`173`	`173`	`};`
`174`	`174`	`return true;`
`175`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,18 +14,18 @@ internal sealed class ConnectionMetrics`
`14`	`14`	`private readonly object _schemeTag;`
`15`	`15`	`private readonly object _hostTag;`
`16`	`16`	`private readonly object? _portTag;`
`17`		`- private readonly object? _socketAddressTag;`
	`17`	`+ private readonly object? _peerAddressTag;`
`18`	`18`	`private bool _currentlyIdle;`
`19`	`19`
`20`		`- public ConnectionMetrics(SocketsHttpHandlerMetrics metrics, string protocolVersion, string scheme, string host, int? port, string? socketAddress)`
	`20`	`+ public ConnectionMetrics(SocketsHttpHandlerMetrics metrics, string protocolVersion, string scheme, string host, int? port, string? peerAddress)`
`21`	`21`	`{`
`22`	`22`	`_metrics = metrics;`
`23`	`23`	`_openConnectionsEnabled = _metrics.OpenConnections.Enabled;`
`24`	`24`	`_protocolVersionTag = protocolVersion;`
`25`	`25`	`_schemeTag = scheme;`
`26`	`26`	`_hostTag = host;`
`27`	`27`	`_portTag = port;`
`28`		`- _socketAddressTag = socketAddress;`
	`28`	`+ _peerAddressTag = peerAddress;`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`// TagList is a huge struct, so we avoid storing it in a field to reduce the amount we allocate on the heap.`
`@@ -42,9 +42,9 @@ private TagList GetTags()`
`42`	`42`	`tags.Add("server.port", _portTag);`
`43`	`43`	`}`
`44`	`44`
`45`		`- if (_socketAddressTag is not null)`
	`45`	`+ if (_peerAddressTag is not null)`
`46`	`46`	`{`
`47`		`- tags.Add("server.socket.address", _socketAddressTag);`
	`47`	`+ tags.Add("network.peer.address", _peerAddressTag);`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`return tags;`
Original file line number	Diff line number	Diff line change
`@@ -23,13 +23,13 @@ public static string GetHostName()`
`23`	`23`	`{`
`24`	`24`	`name = NameResolutionPal.GetHostName();`
`25`	`25`	`}`
`26`		`- catch when (LogFailure(string.Empty, startingTimestamp))`
	`26`	`+ catch (Exception ex) when (LogFailure(string.Empty, startingTimestamp, ex))`
`27`	`27`	`{`
`28`	`28`	`Debug.Fail("LogFailure should return false");`
`29`	`29`	`throw;`
`30`	`30`	`}`
`31`	`31`
`32`		`- NameResolutionTelemetry.Log.AfterResolution(string.Empty, startingTimestamp, successful: true);`
	`32`	`+ NameResolutionTelemetry.Log.AfterResolution(string.Empty, startingTimestamp);`
`33`	`33`
`34`	`34`	`if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(null, name);`
`35`	`35`	`return name;`
`@@ -394,13 +394,13 @@ private static object GetHostEntryOrAddressesCore(string hostName, bool justAddr`
`394`	`394`	`Aliases = aliases`
`395`	`395`	`};`
`396`	`396`	`}`
`397`		`- catch when (LogFailure(hostName, startingTimestamp))`
	`397`	`+ catch (Exception ex) when (LogFailure(hostName, startingTimestamp, ex))`
`398`	`398`	`{`
`399`	`399`	`Debug.Fail("LogFailure should return false");`
`400`	`400`	`throw;`
`401`	`401`	`}`
`402`	`402`
`403`		`- NameResolutionTelemetry.Log.AfterResolution(hostName, startingTimestamp, successful: true);`
	`403`	`+ NameResolutionTelemetry.Log.AfterResolution(hostName, startingTimestamp);`
`404`	`404`
`405`	`405`	`return result;`
`406`	`406`	`}`
`@@ -434,13 +434,13 @@ private static object GetHostEntryOrAddressesCore(IPAddress address, bool justAd`
`434`	`434`	`}`
`435`	`435`	`Debug.Assert(name != null);`
`436`	`436`	`}`
`437`		`- catch when (LogFailure(address, startingTimestamp))`
	`437`	`+ catch (Exception ex) when (LogFailure(address, startingTimestamp, ex))`
`438`	`438`	`{`
`439`	`439`	`Debug.Fail("LogFailure should return false");`
`440`	`440`	`throw;`
`441`	`441`	`}`
`442`	`442`
`443`		`- NameResolutionTelemetry.Log.AfterResolution(address, startingTimestamp, successful: true);`
	`443`	`+ NameResolutionTelemetry.Log.AfterResolution(address, startingTimestamp);`
`444`	`444`
`445`	`445`	`// Do the forward lookup to get the IPs for that host name`
`446`	`446`	`startingTimestamp = NameResolutionTelemetry.Log.BeforeResolution(name);`
`@@ -464,13 +464,13 @@ private static object GetHostEntryOrAddressesCore(IPAddress address, bool justAd`
`464`	`464`	`AddressList = addresses`
`465`	`465`	`};`
`466`	`466`	`}`
`467`		`- catch when (LogFailure(name, startingTimestamp))`
	`467`	`+ catch (Exception ex) when (LogFailure(name, startingTimestamp, ex))`
`468`	`468`	`{`
`469`	`469`	`Debug.Fail("LogFailure should return false");`
`470`	`470`	`throw;`
`471`	`471`	`}`
`472`	`472`
`473`		`- NameResolutionTelemetry.Log.AfterResolution(name, startingTimestamp, successful: true);`
	`473`	`+ NameResolutionTelemetry.Log.AfterResolution(name, startingTimestamp);`
`474`	`474`
`475`	`475`	`// One of three things happened:`
`476`	`476`	`// 1. Success.`
`@@ -577,7 +577,7 @@ private static Task GetHostEntryOrAddressesCoreAsync(string hostName, bool justR`
`577`	`577`	`}`
`578`	`578`
`579`	`579`	`private static Task<T>? GetAddrInfoWithTelemetryAsync<T>(string hostName, bool justAddresses, AddressFamily addressFamily, CancellationToken cancellationToken)`
`580`		`- where T : class`
	`580`	`+ where T : class`
`581`	`581`	`{`
`582`	`582`	`long startingTimestamp = Stopwatch.GetTimestamp();`
`583`	`583`	`Task? task = NameResolutionPal.GetAddrInfoAsync(hostName, justAddresses, addressFamily, cancellationToken);`
`@@ -594,15 +594,19 @@ private static Task GetHostEntryOrAddressesCoreAsync(string hostName, bool justR`
`594`	`594`	`static async Task<T> CompleteAsync(Task task, string hostName, long startingTimestamp)`
`595`	`595`	`{`
`596`	`596`	`_ = NameResolutionTelemetry.Log.BeforeResolution(hostName);`
`597`		`- T? result = null;`
	`597`	`+ Exception? exception = null;`
`598`	`598`	`try`
`599`	`599`	`{`
`600`		`- result = await ((Task<T>)task).ConfigureAwait(false);`
`601`		`- return result;`
	`600`	`+ return await ((Task<T>)task).ConfigureAwait(false);`
	`601`	`+ }`
	`602`	`+ catch (Exception ex)`
	`603`	`+ {`
	`604`	`+ exception = ex;`
	`605`	`+ throw;`
`602`	`606`	`}`
`603`	`607`	`finally`
`604`	`608`	`{`
`605`		`- NameResolutionTelemetry.Log.AfterResolution(hostName, startingTimestamp, successful: result is not null);`
	`609`	`+ NameResolutionTelemetry.Log.AfterResolution(hostName, startingTimestamp, exception);`
`606`	`610`	`}`
`607`	`611`	`}`
`608`	`612`	`}`
`@@ -627,9 +631,9 @@ private static void ValidateHostName(string hostName)`
`627`	`631`	`}`
`628`	`632`	`}`
`629`	`633`
`630`		`- private static bool LogFailure(object hostNameOrAddress, long? startingTimestamp)`
	`634`	`+ private static bool LogFailure(object hostNameOrAddress, long? startingTimestamp, Exception exception)`
`631`	`635`	`{`
`632`		`- NameResolutionTelemetry.Log.AfterResolution(hostNameOrAddress, startingTimestamp, successful: false);`
	`636`	`+ NameResolutionTelemetry.Log.AfterResolution(hostNameOrAddress, startingTimestamp, exception);`
`633`	`637`	`return false;`
`634`	`638`	`}`
`635`	`639`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ public long BeforeResolution(object hostNameOrAddress)`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`[NonEvent]`
`84`		`- public void AfterResolution(object hostNameOrAddress, long? startingTimestamp, bool successful)`
	`84`	`+ public void AfterResolution(object hostNameOrAddress, long? startingTimestamp, Exception? exception = null)`
`85`	`85`	`{`
`86`	`86`	`Debug.Assert(startingTimestamp.HasValue);`
`87`	`87`	`if (startingTimestamp == 0)`
`@@ -99,7 +99,7 @@ public void AfterResolution(object hostNameOrAddress, long? startingTimestamp, b`
`99`	`99`
`100`	`100`	`if (IsEnabled(EventLevel.Informational, EventKeywords.None))`
`101`	`101`	`{`
`102`		`- if (!successful)`
	`102`	`+ if (exception is not null)`
`103`	`103`	`{`
`104`	`104`	`ResolutionFailed();`
`105`	`105`	`}`
`@@ -110,7 +110,7 @@ public void AfterResolution(object hostNameOrAddress, long? startingTimestamp, b`
`110`	`110`
`111`	`111`	`if (NameResolutionMetrics.IsEnabled())`
`112`	`112`	`{`
`113`		`- NameResolutionMetrics.AfterResolution(duration, GetHostnameFromStateObject(hostNameOrAddress));`
	`113`	`+ NameResolutionMetrics.AfterResolution(duration, GetHostnameFromStateObject(hostNameOrAddress), exception);`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`