add a HTTP Tracer

Author: LoneWandererProductions

Communication/HttpWireTracingHandler.cs

@@ -0,0 +1,140 @@
+/*
+ * COPYRIGHT:    See COPYING in the top level directory
+ * PROJECT:      Communication
+ * FILE:         HttpWireTracingHandler.cs
+ * PURPOSE:      HTTP Message Handler middleware for Insomnia-like wire tracing with Trace/String toggle
+ * PROGRAMMER:   Peter Geinitz (Wayfarer)
+ */
+
+using System;
+using System.Diagnostics;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Communication
+{
+    /// <summary>
+    /// Intercept Http messages and trace results. Supports toggling between System.Diagnostics.Trace and String output.
+    /// </summary>
+    /// <seealso cref="DelegatingHandler" />
+    public class HttpWireTracingHandler : DelegatingHandler
+    {
+        private readonly object _lockObj = new object();
+        private string _lastTrace = string.Empty;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the log should be written to <see cref="System.Diagnostics.Trace"/>.
+        /// Default is true.
+        /// </summary>
+        public bool LogToTrace { get; set; } = true;
+
+        /// <summary>
+        /// Optional callback that triggers whenever a new full wire trace string is generated. 
+        /// Perfect for UI bindings (e.g., updating a Blazor log terminal).
+        /// </summary>
+        public Action<string>? OnTraceCaptured { get; set; }
+
+        /// <summary>
+        /// Holds the exact string content of the very last captured HTTP wire trace.
+        /// </summary>
+        public string LastTrace
+        {
+            get
+            {
+                lock (_lockObj) { return _lastTrace; }
+            }
+            private set
+            {
+                lock (_lockObj) { _lastTrace = value; }
+            }
+        }
+
+        /// <summary>
+        /// Sends an HTTP request to the inner handler to send to the server as an asynchronous operation.
+        /// </summary>
+        /// <param name="request">The HTTP request message to send to the server.</param>
+        /// <param name="cancellationToken">A cancellation token to cancel operation.</param>
+        /// <returns>
+        /// The task object representing the asynchronous operation.
+        /// </returns>
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            // Lokaler Speicher für diese spezifische Anfrage (Thread-Safety!)
+            var sb = new StringBuilder();
+
+            sb.AppendLine("\n* ------------------ WIRE TRACE START ------------------ *");
+
+            // 1. REQUEST LOGGING (>)
+            sb.AppendLine($"\n> {request.Method} {request.RequestUri.PathAndQuery} HTTP/{request.Version}");
+            sb.AppendLine($"> Host: {request.RequestUri.Host}");
+
+            foreach (var header in request.Headers)
+            {
+                sb.AppendLine($"> {header.Key}: {string.Join(", ", header.Value)}");
+            }
+
+            if (request.Content != null)
+            {
+                foreach (var header in request.Content.Headers)
+                {
+                    sb.AppendLine($"> {header.Key}: {string.Join(", ", header.Value)}");
+                }
+
+                // Buffer content safely so we don't disrupt the stream
+                await request.Content.LoadIntoBufferAsync();
+                var reqBody = await request.Content.ReadAsStringAsync();
+                if (!string.IsNullOrEmpty(reqBody))
+                {
+                    sb.AppendLine("> ");
+                    sb.AppendLine(reqBody.Length > 1000 ? reqBody.Substring(0, 1000) + "... [TRUNCATED]" : reqBody);
+                }
+            }
+
+            sb.AppendLine("\n* Technical upload complete, awaiting response...");
+
+            // Execute the actual HTTP Call
+            var response = await base.SendAsync(request, cancellationToken);
+
+            // 2. RESPONSE LOGGING (<)
+            sb.AppendLine($"\n< HTTP/{response.Version} {(int)response.StatusCode} {response.StatusCode}");
+
+            foreach (var header in response.Headers)
+            {
+                sb.AppendLine($"< {header.Key}: {string.Join(", ", header.Value)}");
+            }
+            if (response.Content != null)
+            {
+                foreach (var header in response.Content.Headers)
+                {
+                    sb.AppendLine($"< {header.Key}: {string.Join(", ", header.Value)}");
+                }
+
+                var resBody = await response.Content.ReadAsStringAsync();
+                if (!string.IsNullOrEmpty(resBody))
+                {
+                    sb.AppendLine("< ");
+                    sb.AppendLine(resBody);
+                }
+            }
+
+            sb.AppendLine("\n* ------------------- WIRE TRACE END ------------------- *\n");
+
+            // --- AUSWERTUNG DES WECHSELSCHALTERS ---
+            string finalTraceLog = sb.ToString();
+            LastTrace = finalTraceLog;
+
+            // Schalter 1: Standard System.Diagnostics.Trace
+            if (LogToTrace)
+            {
+                Trace.Write(finalTraceLog);
+            }
+
+            // Schalter 2: Event/Callback für String-Verarbeitung abfeuern
+            OnTraceCaptured?.Invoke(finalTraceLog);
+
+            return response;
+        }
+    }
+}

CommunicationTests/HttpWireTracingHandlerTests.cs

@@ -0,0 +1,113 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     CommunicationTests
+ * FILE:         HttpWireTracingHandlerTests.cs
+ * PURPOSE:      Unit tests for HttpWireTracingHandler ensuring correct request/response interception and tracing
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+using System.Diagnostics;
+using System.Net;
+using System.Text;
+using Communication;
+
+namespace CommunicationTests
+{
+    /// <summary>
+    /// Test our new Http wire tracer.
+    /// </summary>
+    [TestClass]
+    public class HttpWireTracingHandlerTests
+    {
+        /// <summary>
+        /// The test URL
+        /// </summary>
+        private const string TestUrl = "https://localhost/test/api/endpoint";
+
+        /// <summary>
+        /// Sends the asynchronous should log request and response to trace and return correct response.
+        /// </summary>
+        [TestMethod]
+        public async Task SendAsync_ShouldLogRequestAndResponseToTrace_AndReturnCorrectResponse()
+        {
+            // Arrange
+            using var stringWriter = new StringWriter();
+            using var traceListener = new TextWriterTraceListener(stringWriter);
+            Trace.Listeners.Add(traceListener);
+
+            var expectedResponseBody = "{\"status\":\"success\",\"message\":\"f81dcbd2\"}";
+            var innerHandler = new MockHttpMessageHandler(HttpStatusCode.OK, expectedResponseBody);
+
+            var tracingHandler = new HttpWireTracingHandler
+            {
+                //switch Trace one and off
+                LogToTrace = true,
+                InnerHandler = innerHandler
+            };
+
+            using var client = new HttpClient(tracingHandler);
+            var requestContent = new StringContent("{\"input\":\"data_from_riesa\"}", Encoding.UTF8, "application/json");
+
+            try
+            {
+                // Act
+                var response = await client.PostAsync(TestUrl, requestContent);
+                var actualResponseBody = await response.Content.ReadAsStringAsync();
+
+                // Erzwinge das Schreiben aller gepufferten Trace-Daten
+                Trace.Flush();
+                var traceOutput = stringWriter.ToString();
+
+                // Assert 1: Überprüfung der echten HTTP-Funktionalität
+                Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
+                Assert.AreEqual(expectedResponseBody, actualResponseBody);
+
+                // Assert 2: Überprüfung der Wire-Trace Struktur (Insomnia Layout)
+                Assert.IsTrue(traceOutput.Contains("WIRE TRACE START"), "Trace missing start boundary.");
+                Assert.IsTrue(traceOutput.Contains("WIRE TRACE END"), "Trace missing end boundary.");
+
+                // Assert 3: Validierung der Request-Daten (>)
+                Assert.IsTrue(traceOutput.Contains("> POST /test/api/endpoint"), "Request method or path path not traced correctly.");
+                Assert.IsTrue(traceOutput.Contains("> Host: localhost"), "Request host header missing in trace.");
+                Assert.IsTrue(traceOutput.Contains("Content-Type: application/json"), "Content-Type header missing in request trace.");
+                Assert.IsTrue(traceOutput.Contains("{\"input\":\"data_from_riesa\"}"), "Request body payload missing in trace.");
+
+                // Assert 4: Validierung der Response-Daten (<)
+                Assert.IsTrue(traceOutput.Contains("< HTTP/1.1 200 OK"), "Response status code line missing or incorrect in trace.");
+                Assert.IsTrue(traceOutput.Contains(expectedResponseBody), "Response body payload missing in trace.");
+            }
+            finally
+            {
+                // Berebereinigung des Trace-Listeners, um Seiteneffekte auf andere Tests zu verhindern
+                Trace.Listeners.Remove(traceListener);
+            }
+        }
+
+        /// <summary>
+        /// A local HTTP mock handler for simulating network traffic without using the physical connection.
+        /// </summary>
+        /// <seealso cref="HttpMessageHandler" />
+        private class MockHttpMessageHandler : HttpMessageHandler
+        {
+            private readonly HttpStatusCode _statusCode;
+            private readonly string _content;
+
+            public MockHttpMessageHandler(HttpStatusCode statusCode, string content)
+            {
+                _statusCode = statusCode;
+                _content = content;
+            }
+
+            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+            {
+                var response = new HttpResponseMessage(_statusCode)
+                {
+                    Content = new StringContent(_content, Encoding.UTF8, "application/json"),
+                    Version = request.Version
+                };
+
+                return Task.FromResult(response);
+            }
+        }
+    }
+}