feat(server): add UseConnectionLogging() and wire through to ConnectionActor

Author: st0o0

src/TurboHTTP.Tests/Server/TurboListenOptionsSpec.cs

@@ -114,6 +114,29 @@ public void UseHttps_called_twice_should_use_last_configuration()
         Assert.Null(options.HttpsOptions.CertificatePath);
     }
 
+    [Fact(Timeout = 5000)]
+    public void ConnectionLoggingCategory_should_be_null_by_default()
+    {
+        var options = new TurboListenOptions(IPAddress.Loopback, 80);
+        Assert.Null(options.ConnectionLoggingCategory);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void UseConnectionLogging_should_set_default_category()
+    {
+        var options = new TurboListenOptions(IPAddress.Loopback, 80);
+        options.UseConnectionLogging();
+        Assert.Equal("TurboHTTP.Server.ConnectionLogging", options.ConnectionLoggingCategory);
+    }
+
+    [Fact(Timeout = 5000)]
+    public void UseConnectionLogging_with_name_should_set_custom_category()
+    {
+        var options = new TurboListenOptions(IPAddress.Loopback, 80);
+        options.UseConnectionLogging("MyApp.WireLog");
+        Assert.Equal("MyApp.WireLog", options.ConnectionLoggingCategory);
+    }
+
     private static X509Certificate2 CreateSelfSignedCert()
     {
         using var rsa = System.Security.Cryptography.RSA.Create(2048);

src/TurboHTTP/Server/Hosting/TurboServerHostedService.cs

@@ -71,7 +71,8 @@ public async Task StartAsync(CancellationToken cancellationToken)
                 pipeline,
                 routeTable,
                 _services,
-                materializer));
+                materializer,
+                endpoint.ConnectionLoggingCategory));
         }
 
         _supervisor = _system.ActorOf(

src/TurboHTTP/Server/Internal/EndpointResolver.cs

@@ -195,7 +195,8 @@ private static ListenerBinding CreateTcpBinding(TurboListenOptions listen, X509C
         return new ListenerBinding
         {
             Options = tcpOptions,
-            Factory = new TcpListenerFactory()
+            Factory = new TcpListenerFactory(),
+            ConnectionLoggingCategory = listen.ConnectionLoggingCategory
         };
     }
 
@@ -215,7 +216,8 @@ private static ListenerBinding CreateQuicBinding(TurboListenOptions listen, X509
         return new ListenerBinding
         {
             Options = quicOptions,
-            Factory = new QuicListenerFactory()
+            Factory = new QuicListenerFactory(),
+            ConnectionLoggingCategory = listen.ConnectionLoggingCategory
         };
     }
 }

src/TurboHTTP/Server/ListenerBinding.cs

@@ -6,4 +6,5 @@ public sealed class ListenerBinding
 {
     public required ListenerOptions Options { get; init; }
     public required IListenerFactory Factory { get; init; }
+    public string? ConnectionLoggingCategory { get; init; }
 }

src/TurboHTTP/Server/TurboListenOptions.cs

@@ -52,4 +52,16 @@ public void UseHttps(string path, string? password, Action<TurboHttpsOptions> co
         };
         configure(HttpsOptions);
     }
+
+    internal string? ConnectionLoggingCategory { get; private set; }
+
+    public void UseConnectionLogging()
+    {
+        ConnectionLoggingCategory = "TurboHTTP.Server.ConnectionLogging";
+    }
+
+    public void UseConnectionLogging(string loggerName)
+    {
+        ConnectionLoggingCategory = loggerName;
+    }
 }

src/TurboHTTP/Streams/Lifecycle/ConnectionActor.cs

@@ -3,7 +3,10 @@
 using Akka.Event;
 using Akka.Streams;
 using Akka.Streams.Dsl;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Servus.Akka.Transport;
+using TurboHTTP.Diagnostics;
 using TurboHTTP.Routing;
 using TurboHTTP.Server;
 using TurboHTTP.Server.Middleware;
@@ -34,7 +37,8 @@ public sealed record Materialize(
         RouteTable RouteTable,
         TurboConnectionInfo ConnectionInfo,
         IServiceProvider Services,
-        IMaterializer Materializer);
+        IMaterializer Materializer,
+        string? ConnectionLoggingCategory = null);
 
     public sealed record GracefulStop(TimeSpan Timeout);
 
@@ -82,9 +86,38 @@ private void OnMaterialize(Materialize msg)
                 return item;
             });
 
-        var completionTask = msg.ConnectionFlow
+        Flow<ITransportInbound, ITransportInbound, NotUsed>? loggingFlow = null;
+        if (msg.ConnectionLoggingCategory is { } loggingCategory)
+        {
+            var loggerFactory = msg.Services.GetRequiredService<ILoggerFactory>();
+            var logger = loggerFactory.CreateLogger(loggingCategory);
+            if (logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
+            {
+                loggingFlow = Flow.Create<ITransportInbound>()
+                    .Select(item =>
+                    {
+                        if (item is TransportData { Buffer: var buffer })
+                        {
+                            var dump = HexDumpFormatter.Format(buffer.Span);
+                            logger.LogDebug("ReadAsync[{Length}]{NewLine}{Dump}",
+                                buffer.Length, Environment.NewLine, dump);
+                        }
+
+                        return item;
+                    });
+            }
+        }
+
+        var pipeline = msg.ConnectionFlow
             .Via(_killSwitch.Flow<ITransportInbound>())
-            .Via(inboundTap)
+            .Via(inboundTap);
+
+        if (loggingFlow is not null)
+        {
+            pipeline = pipeline.Via(loggingFlow);
+        }
+
+        var completionTask = pipeline
             .ViaMaterialized(
                 Flow.Create<ITransportInbound>().WatchTermination(Keep.Right),
                 Keep.Right)

src/TurboHTTP/Streams/Lifecycle/ListenerActor.cs

@@ -20,6 +20,7 @@ internal sealed class ListenerActor : ReceiveActor
     private readonly RouteTable _routeTable;
     private readonly IServiceProvider _services;
     private readonly IMaterializer _materializer;
+    private readonly string? _connectionLoggingCategory;
 
     private UniqueKillSwitch? _listenerKillSwitch;
     private int _connectionCounter;
@@ -48,7 +49,8 @@ public ListenerActor(
         TurboRequestDelegate pipeline,
         RouteTable routeTable,
         IServiceProvider services,
-        IMaterializer materializer)
+        IMaterializer materializer,
+        string? connectionLoggingCategory = null)
     {
         _factory = factory;
         _listenerOptions = listenerOptions;
@@ -57,6 +59,7 @@ public ListenerActor(
         _routeTable = routeTable;
         _services = services;
         _materializer = materializer;
+        _connectionLoggingCategory = connectionLoggingCategory;
 
         Receive<StartListening>(_ => OnStartListening());
         Receive<IncomingConnection>(OnIncomingConnection);
@@ -120,7 +123,8 @@ private void OnIncomingConnection(IncomingConnection msg)
             _routeTable,
             connectionInfo,
             _services,
-            _materializer));
+            _materializer,
+            _connectionLoggingCategory));
 
         Context.Parent.Tell(new ConnectionStarted(connectionId, child));
     }
@@ -193,8 +197,10 @@ public static Props Create(
         TurboRequestDelegate pipeline,
         RouteTable routeTable,
         IServiceProvider services,
-        IMaterializer materializer)
+        IMaterializer materializer,
+        string? connectionLoggingCategory = null)
         => Props.Create(() => new ListenerActor(
             factory, listenerOptions, serverOptions,
-            pipeline, routeTable, services, materializer));
+            pipeline, routeTable, services, materializer,
+            connectionLoggingCategory));
 }