refactor: deduplicate Event::Request fields, add mpsc benchmark

Remove duplicate method/path/trusted_ip from Event::Request - access
via request.* instead. Add mpsc benchmark directory for comparison.

Author: cablehead

benchmarks/bench-mpsc-logging/README.md

@@ -0,0 +1,23 @@
+# Benchmark: mpsc-logging
+
+> **Note:** Run benchmarks only with this branch checked out: `git checkout bench-mpsc-logging`
+
+Comparing mpsc channel vs broadcast channel for logging.
+
+## Setup
+- Event enum is owned (no Clone needed for mpsc)
+- emit() sends to std::sync::mpsc::Sender (non-blocking)
+- Handlers run in dedicated threads with blocking recv()
+- No clone on receive (mpsc moves ownership)
+
+## Run
+```bash
+nu run.nu          # run and display
+nu run.nu --save   # run and save to results.nuon
+
+# Manual testing against a running server
+oha -z 5s -c 50 http://127.0.0.1:3001/
+```
+
+## Results
+See `results.nuon`

benchmarks/bench-mpsc-logging/results.nuon

@@ -0,0 +1 @@
+[[format, requests_per_sec, avg_latency_ms, dropped, connections, duration]; [jsonl, 24373.74, 2.04, 0, 50, "5s"], [human, 25352.79, 1.96, 0, 50, "5s"]]

benchmarks/bench-mpsc-logging/run.nu

@@ -0,0 +1,65 @@
+#!/usr/bin/env nu
+
+# Benchmark script for broadcast-based logging
+
+def main [
+    --duration (-d): string = "5s"  # Duration per test
+    --connections (-c): int = 50    # Concurrent connections
+    --save (-s)                     # Save results to results.nuon
+] {
+    let script_dir = ($env.FILE_PWD? | default ".")
+    let root = $"($script_dir)/../.."
+
+    print "Building release..."
+    cargo build --release --quiet
+
+    mut results = []
+
+    for format in ["jsonl", "human"] {
+        let port = 9990 + ($results | length)
+        let logfile = $"/tmp/http-nu-bench-($port).log"
+        print $"Testing ($format) on :($port)..."
+
+        # Start server, capture output to check for lag
+        bash -c $"($root)/target/release/http-nu --log-format ($format) :($port) '{|req| {body: \"hello\"}}' > ($logfile) 2>&1 &"
+        sleep 1sec
+
+        # Run benchmark
+        let oha_out = (oha -z $duration -c $connections $"http://127.0.0.1:($port)/" | complete).stdout
+
+        # Kill server
+        pkill -f $"http-nu.*:($port)"
+        sleep 500ms
+
+        # Parse benchmark results
+        let rps = ($oha_out | parse -r 'Requests/sec:\s+([\d.]+)' | get 0?.capture0? | default "0" | into float)
+        let avg = ($oha_out | parse -r 'Average:\s+([\d.]+)\s+ms' | get 0?.capture0? | default "0" | into float)
+
+        # Check for lag (jsonl: "lagged" in JSON, human: "logging lagged" on stderr)
+        let dropped = if $format == "jsonl" {
+            let lagged = (open $logfile | lines | where {|l| $l =~ '"message":"lagged"'} | each {|l| $l | from json | get dropped})
+            if ($lagged | is-empty) { 0 } else { $lagged | math sum }
+        } else {
+            let count = (grep -c "logging lagged" $logfile | complete | get stdout | str trim)
+            if ($count | is-empty) { 0 } else { $count | into int }
+        }
+
+        $results = ($results | append {
+            format: $format
+            requests_per_sec: ($rps | math round -p 2)
+            avg_latency_ms: ($avg | math round -p 2)
+            dropped: $dropped
+            connections: $connections
+            duration: $duration
+        })
+
+        rm -f $logfile
+    }
+
+    if $save {
+        $results | to nuon | save -f $"($script_dir)/results.nuon"
+        print $"Saved to ($script_dir)/results.nuon"
+    }
+
+    $results
+}

src/logging.rs

@@ -55,9 +55,6 @@ pub enum Event {
     // Access events
     Request {
         request_id: scru128::Scru128Id,
-        method: String,
-        path: String,
-        trusted_ip: Option<String>,
         request: Box<RequestData>,
     },
     Response {
@@ -111,13 +108,9 @@ fn emit(event: Event) {
 // --- Public emit functions ---
 
 pub fn log_request(request_id: scru128::Scru128Id, request: &Request) {
-    let data = RequestData::from(request);
     emit(Event::Request {
         request_id,
-        method: data.method.clone(),
-        path: data.path.clone(),
-        trusted_ip: data.trusted_ip.clone(),
-        request: Box::new(data),
+        request: Box::new(RequestData::from(request)),
     });
 }
 
@@ -218,18 +211,15 @@ pub fn run_jsonl_handler(rx: broadcast::Receiver<Event>) {
             let json = match event {
                 Event::Request {
                     request_id,
-                    method,
-                    path,
-                    trusted_ip,
                     request,
                 } => {
                     serde_json::json!({
                         "stamp": stamp,
                         "message": "request",
                         "request_id": request_id.to_string(),
-                        "method": method,
-                        "path": path,
-                        "trusted_ip": trusted_ip,
+                        "method": &request.method,
+                        "path": &request.path,
+                        "trusted_ip": &request.trusted_ip,
                         "request": request,
                     })
                 }
@@ -414,10 +404,7 @@ pub fn run_human_handler(rx: broadcast::Receiver<Event>) {
                 }
                 Event::Request {
                     request_id,
-                    method,
-                    path,
-                    trusted_ip,
-                    ..
+                    request,
                 } => {
                     let now = std::time::Instant::now();
                     if now.duration_since(last_shown) < min_interval {
@@ -437,9 +424,9 @@ pub fn run_human_handler(rx: broadcast::Receiver<Event>) {
 
                     let state = RequestState {
                         pb: pb.clone(),
-                        method,
-                        path,
-                        trusted_ip,
+                        method: request.method.clone(),
+                        path: request.path.clone(),
+                        trusted_ip: request.trusted_ip.clone(),
                         status: None,
                         latency_ms: None,
                     };