chore: clean up

Author: st0o0

src/Servus.Akka.TestKit.Tests/TestPipelineSpec.cs

@@ -23,7 +23,7 @@ public async Task RunAsync_should_return_single_result()
         var result = await TestPipeline.RunAsync(
             stage.AsFlow(),
             new ConnectTransport(new TcpTransportOptions { Host = "localhost", Port = 80 }),
-            _materializer, ct);
+            _materializer, ct: ct);
 
         Assert.IsType<TransportConnected>(result);
     }
@@ -46,11 +46,11 @@ public async Task RunManyAsync_should_collect_expected_count()
         };
 
         var results = await TestPipeline.RunManyAsync(
-            stage.AsFlow(), inputs, 3, _materializer, ct);
+            stage.AsFlow(), inputs, 3, _materializer, ct: ct);
 
         Assert.Equal(3, results.Count);
         Assert.IsType<TransportConnected>(results[0]);
         Assert.IsType<TransportData>(results[1]);
         Assert.IsType<TransportData>(results[2]);
     }
-}
+}

src/Servus.Akka.TestKit/TestConnectionStageBuilder.cs

@@ -18,8 +18,8 @@ public TestConnectionStageBuilder AutoConnect(ConnectionInfo? info = null)
 
     public TestConnectionStageBuilder AutoDisconnect()
     {
-        return OnOutbound<DisconnectTransport>((msg, ctx) =>
-            ctx.Push(new TransportDisconnected(msg.Reason)));
+        return OnOutbound<DisconnectTransport>((msg, ctx) 
+            => ctx.Push(new TransportDisconnected(msg.Reason)));
     }
 
     public TestConnectionStageBuilder OnOutbound<T>(Action<T, IStageContext> handler)
@@ -39,9 +39,7 @@ public TestConnectionStageBuilder WithActivityLog(ActivityLog log)
 
     public TestConnectionStage Build()
     {
-        var stage = new TestConnectionStage(
-            new List<TestConnectionStage.OutboundHandler>(_handlers),
-            _activityLog);
+        var stage = new TestConnectionStage([.._handlers], _activityLog);
 
         if (_autoConnect)
         {

src/Servus.Akka.TestKit/TestPipeline.cs

@@ -12,8 +12,8 @@ public static async Task<TOut> RunAsync<TIn, TOut>(
         Flow<TIn, TOut, NotUsed> flow,
         TIn input,
         IMaterializer materializer,
-        CancellationToken ct = default,
-        TimeSpan? timeout = null)
+        TimeSpan? timeout = null,
+        CancellationToken ct = default)
     {
         var result = Source.Single(input)
             .Via(flow)
@@ -27,8 +27,8 @@ public static async Task<IReadOnlyList<TOut>> RunManyAsync<TIn, TOut>(
         IEnumerable<TIn> inputs,
         int expectedCount,
         IMaterializer materializer,
-        CancellationToken ct = default,
-        TimeSpan? timeout = null)
+        TimeSpan? timeout = null,
+        CancellationToken ct = default)
     {       
         var result = Source.From(inputs)
             .Via(flow)

src/Servus.Akka.Tests/Transport/Quic/Client/QuicClientProviderSpec.cs

@@ -8,7 +8,7 @@
 
 namespace Servus.Akka.Tests.Transport.Quic.Client;
 
-[Collection("TransportBuffer")]
+[Collection("ClientProvider")]
 public sealed class QuicClientProviderSpec
 {
     private static async Task<Stream> GetStreamOrSkipAsync(QuicClientProvider provider, CancellationToken ct)

src/Servus.Akka.Tests/Transport/Quic/QuicMultiStreamSpec.cs

@@ -1,4 +1,4 @@
-using Servus.Akka.Tests.Utils;
+using Servus.Akka.Tests.Utils;
 using Servus.Akka.Transport;
 using Servus.Akka.Transport.Quic;
 using Servus.Akka.Transport.Quic.Client;

src/Servus.Akka.Tests/Transport/Tcp/Client/TcpClientProviderSpec.cs

@@ -6,6 +6,10 @@
 
 namespace Servus.Akka.Tests.Transport.Tcp.Client;
 
+[CollectionDefinition("ClientProvider", DisableParallelization = true)]
+public class ClientProviderCollection;
+
+[Collection("ClientProvider")]
 public sealed class TcpClientProviderSpec
 {
     [Fact(Timeout = 5000)]

src/Servus.Akka.Tests/Transport/Tcp/Client/TlsClientProviderSpec.cs

@@ -8,6 +8,7 @@
 
 namespace Servus.Akka.Tests.Transport.Tcp.Client;
 
+[Collection("ClientProvider")]
 public sealed class TlsClientProviderSpec
 {
     [Fact(Timeout = 5000)]

src/Servus.Akka.Tests/Transport/TransportBufferSpec.cs

@@ -2,6 +2,9 @@
 
 namespace Servus.Akka.Tests.Transport;
 
+[CollectionDefinition("TransportBuffer", DisableParallelization = true)]
+public class TransportBufferCollection;
+
 [Collection("TransportBuffer")]
 public sealed class TransportBufferSpec
 {

src/Servus.Akka/Servus.Akka.csproj

@@ -1,15 +1,16 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <TargetFramework>net10.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <IsPackable>false</IsPackable>
+        <!-- slopwatch-ignore: SW005 QUIC APIs are platform-guarded at runtime; CA1416 false-positives on conditional usage -->
         <NoWarn>CA1416</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Akka.Hosting"/>
+        <PackageReference Include="Akka.Hosting" />
         <PackageReference Include="Servus.Core" />
     </ItemGroup>
 

src/Servus.Akka/Transport/ServusExtensions.cs

@@ -0,0 +1,75 @@
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+using Servus.Core.Diagnostics;
+
+namespace Servus.Akka.Transport;
+
+internal static class ServusExtensions
+{
+    private static Histogram<double>? _dnsLookupDuration;
+    private static Histogram<double>? _socketConnectDuration;
+
+    public static Histogram<double> DnsLookupDuration(this ServusMetrics metrics)
+    {
+        return _dnsLookupDuration ??= metrics.Meter.CreateHistogram<double>(
+            "dns.lookup.duration",
+            unit: "s",
+            description: "Duration of DNS lookups in seconds");
+    }
+
+    public static Histogram<double> SocketConnectDuration(this ServusMetrics metrics)
+    {
+        return _socketConnectDuration ??= metrics.Meter.CreateHistogram<double>(
+            "network.socket.connect.duration",
+            unit: "s",
+            description: "Duration of socket connect operations in seconds");
+    }
+}
+
+internal static class ServusTraceExtensions
+{
+    public static Activity? StartDnsLookup(this ServusTrace trace, string hostname)
+    {
+        if (!trace.Source.HasListeners())
+        {
+            return null;
+        }
+
+        var activity = trace.Source.StartActivity("dns.lookup", ActivityKind.Client);
+        activity?.SetTag("dns.question.name", hostname);
+        return activity;
+    }
+
+    public static void SetDnsAnswers(this ServusTrace _, Activity activity, string[] answers)
+    {
+        activity.SetTag("dns.answers", string.Join(",", answers));
+        activity.SetTag("dns.answer.count", answers.Length);
+    }
+
+    public static Activity? StartSocketConnect(this ServusTrace trace, string address, int port, string transport, string networkType)
+    {
+        if (!trace.Source.HasListeners())
+        {
+            return null;
+        }
+
+        var activity = trace.Source.StartActivity("network.socket.connect", ActivityKind.Client);
+        if (activity is null)
+        {
+            return null;
+        }
+
+        activity.SetTag("network.peer.address", address);
+        activity.SetTag("network.peer.port", port);
+        activity.SetTag("network.transport", transport);
+        activity.SetTag("network.type", networkType);
+        return activity;
+    }
+
+    public static void SetError(this ServusTrace _, Activity activity, Exception exception)
+    {
+        activity.SetStatus(ActivityStatusCode.Error, exception.Message);
+        activity.SetTag("error.type", exception.GetType().FullName);
+        activity.SetTag("exception.message", exception.Message);
+    }
+}