Add exceeded max concurrent connections reason

Author: JamesNK

src/Servers/Kestrel/Core/src/Internal/Infrastructure/KestrelMetrics.cs

@@ -157,6 +157,8 @@ private void ConnectionStopCore(in ConnectionMetricsContext metricsContext, Exce
 
     public void ConnectionRejected(in ConnectionMetricsContext metricsContext)
     {
+        AddConnectionEndReason(metricsContext, ConnectionEndReason.MaxConcurrentConnectionsExceeded);
+
         // Check live rather than cached state because this is just a counter, it's not a start/stop event like the other metrics.
         if (_rejectedConnectionsCounter.Enabled)
         {
@@ -509,6 +511,7 @@ internal static bool TryGetErrorType(ConnectionEndReason reason, [NotNullWhen(tr
             ConnectionEndReason.TlsOverHttp => "tls_over_http",
             ConnectionEndReason.MaxRequestBodySizeExceeded => "max_request_body_size_exceeded",
             ConnectionEndReason.UnexpectedEndOfRequestContent => "unexpected_end_of_request_content",
+            ConnectionEndReason.MaxConcurrentConnectionsExceeded => "max_concurrent_connections_exceeded",
             _ => throw new InvalidOperationException($"Unable to calculate whether {reason} resolves to error.type value.")
         };
 

src/Servers/Kestrel/test/FunctionalTests/ConnectionMiddlewareTests.cs

@@ -1,17 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
-using System.Collections.Concurrent;
-using System.IO;
 using System.IO.Pipelines;
 using System.Net;
-using System.Threading;
-using System.Threading.Tasks;
+using Microsoft.AspNetCore.InternalTesting;
 using Microsoft.AspNetCore.Server.Kestrel.Core;
 using Microsoft.AspNetCore.Server.Kestrel.FunctionalTests;
-using Microsoft.AspNetCore.InternalTesting;
-using Xunit;
 
 #if SOCKETS
 namespace Microsoft.AspNetCore.Server.Kestrel.Sockets.FunctionalTests;

src/Servers/Kestrel/test/InMemory.FunctionalTests/ConnectionLimitTests.cs

@@ -104,6 +104,7 @@ public async Task RejectsConnectionsWhenLimitReached()
     {
         var testMeterFactory = new TestMeterFactory();
         using var rejectedConnections = new MetricCollector<long>(testMeterFactory, "Microsoft.AspNetCore.Server.Kestrel", "kestrel.rejected_connections");
+        using var connectionDuration = new MetricCollector<double>(testMeterFactory, "Microsoft.AspNetCore.Server.Kestrel", "kestrel.connection.duration");
 
         const int max = 10;
         var requestTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -149,6 +150,30 @@ public async Task RejectsConnectionsWhenLimitReached()
             }
         }
 
+        var measurements = connectionDuration.GetMeasurementSnapshot();
+
+        Assert.Collection(measurements,
+            m => Assert.Equal(KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded), m.Tags[KestrelMetrics.ErrorType]),
+            m => Assert.Equal(KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded), m.Tags[KestrelMetrics.ErrorType]),
+            m => Assert.Equal(KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded), m.Tags[KestrelMetrics.ErrorType]),
+            m => Assert.Equal(KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded), m.Tags[KestrelMetrics.ErrorType]),
+            m => Assert.Equal(KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded), m.Tags[KestrelMetrics.ErrorType]),
+            m => Assert.Equal(KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded), m.Tags[KestrelMetrics.ErrorType]),
+            m => Assert.Equal(KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded), m.Tags[KestrelMetrics.ErrorType]),
+            m => Assert.Equal(KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded), m.Tags[KestrelMetrics.ErrorType]),
+            m => Assert.Equal(KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded), m.Tags[KestrelMetrics.ErrorType]),
+            m => Assert.Equal(KestrelMetrics.GetErrorType(ConnectionEndReason.MaxConcurrentConnectionsExceeded), m.Tags[KestrelMetrics.ErrorType]),
+            m => Assert.DoesNotContain(KestrelMetrics.ErrorType, m.Tags.Keys),
+            m => Assert.DoesNotContain(KestrelMetrics.ErrorType, m.Tags.Keys),
+            m => Assert.DoesNotContain(KestrelMetrics.ErrorType, m.Tags.Keys),
+            m => Assert.DoesNotContain(KestrelMetrics.ErrorType, m.Tags.Keys),
+            m => Assert.DoesNotContain(KestrelMetrics.ErrorType, m.Tags.Keys),
+            m => Assert.DoesNotContain(KestrelMetrics.ErrorType, m.Tags.Keys),
+            m => Assert.DoesNotContain(KestrelMetrics.ErrorType, m.Tags.Keys),
+            m => Assert.DoesNotContain(KestrelMetrics.ErrorType, m.Tags.Keys),
+            m => Assert.DoesNotContain(KestrelMetrics.ErrorType, m.Tags.Keys),
+            m => Assert.DoesNotContain(KestrelMetrics.ErrorType, m.Tags.Keys));
+
         static void AssertCounter(CollectedMeasurement<long> measurement) => Assert.Equal(1, measurement.Value);
     }
 

src/Servers/Kestrel/test/InMemory.FunctionalTests/ConnectionMiddlewareTests.cs

@@ -16,6 +16,8 @@
 using Microsoft.AspNetCore.InternalTesting;
 using Microsoft.Extensions.Logging.Testing;
 using Xunit;
+using Microsoft.Extensions.Diagnostics.Metrics.Testing;
+using Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Infrastructure;
 
 namespace Microsoft.AspNetCore.Server.Kestrel.InMemory.FunctionalTests;
 
@@ -150,10 +152,13 @@ public async Task ImmediateFinAfterOnConnectionAsyncClosesGracefully(RequestDele
     [MemberData(nameof(EchoAppRequestDelegates))]
     public async Task ImmediateFinAfterThrowingClosesGracefully(RequestDelegate requestDelegate)
     {
+        var testMeterFactory = new TestMeterFactory();
+        using var connectionDuration = new MetricCollector<double>(testMeterFactory, "Microsoft.AspNetCore.Server.Kestrel", "kestrel.connection.duration");
+
         var listenOptions = new ListenOptions(new IPEndPoint(IPAddress.Loopback, 0));
         listenOptions.Use(next => context => throw new InvalidOperationException());
 
-        var serviceContext = new TestServiceContext(LoggerFactory);
+        var serviceContext = new TestServiceContext(LoggerFactory, metrics: new KestrelMetrics(testMeterFactory));
 
         await using (var server = new TestServer(requestDelegate, serviceContext, listenOptions))
         {
@@ -164,6 +169,11 @@ public async Task ImmediateFinAfterThrowingClosesGracefully(RequestDelegate requ
                 await connection.WaitForConnectionClose();
             }
         }
+
+        Assert.Collection(connectionDuration.GetMeasurementSnapshot(), m =>
+        {
+            Assert.Equal(typeof(InvalidOperationException).FullName, m.Tags[KestrelMetrics.ErrorType]);
+        });
     }
 
     [Theory]

src/Shared/ServerInfrastructure/Http2/ConnectionEndReason.cs

@@ -49,5 +49,6 @@ internal enum ConnectionEndReason
     TlsHandshakeFailed,
     TlsOverHttp,
     MaxRequestBodySizeExceeded,
-    UnexpectedEndOfRequestContent
+    UnexpectedEndOfRequestContent,
+    MaxConcurrentConnectionsExceeded
 }