fix: address Codex review — parser latency unit, URI extraction, diagnostics

- Cloudflare: OriginResponseTime correctly converted from nanoseconds to ms
  (was consumed raw, 1000x underestimation)
- Fastly: URI extraction handles all HTTP methods (was GET/POST only)
- Both parsers: warn messages include file path and line number for diagnosis
- Both parsers: non-UTF-8 lines logged instead of silently dropped
- Calibrate sensitivity analysis: uses train_policy + eval_with_keys
  (was re-training on validation data)

Author: albert-einshutoin

crates/qc-cli/src/providers/cloudflare.rs

@@ -32,17 +32,23 @@ impl ProviderLogParser for CloudflareParser {
         const MAX_LINE_BYTES: usize = 64 * 1024;
         let mut buf = Vec::with_capacity(4096);
         let mut reader = reader;
+        let mut line_num = 0usize;
 
         loop {
             buf.clear();
+            line_num += 1;
             let bytes_read = (&mut reader)
                 .take((MAX_LINE_BYTES + 1) as u64)
                 .read_until(b'\n', &mut buf)?;
             if bytes_read == 0 {
                 break;
             }
             if buf.len() > MAX_LINE_BYTES && !buf.ends_with(b"\n") {
-                tracing::warn!("skipping oversized line (>{MAX_LINE_BYTES} bytes)");
+                tracing::warn!(
+                    "{}:{}: skipping oversized line (>{MAX_LINE_BYTES} bytes)",
+                    path.display(),
+                    line_num
+                );
                 loop {
                     buf.clear();
                     let n = (&mut reader)
@@ -56,7 +62,10 @@ impl ProviderLogParser for CloudflareParser {
             }
             let line = match std::str::from_utf8(&buf) {
                 Ok(s) => s.trim(),
-                Err(_) => continue,
+                Err(_) => {
+                    tracing::warn!("{}:{}: skipping non-UTF-8 line", path.display(), line_num);
+                    continue;
+                }
             };
             if line.is_empty() {
                 continue;
@@ -66,7 +75,11 @@ impl ProviderLogParser for CloudflareParser {
                 Ok(Some(e)) => events.push(e),
                 Ok(None) => {}
                 Err(e) => {
-                    tracing::warn!("skipping malformed line: {e}");
+                    tracing::warn!(
+                        "{}:{}: skipping malformed line: {e}",
+                        path.display(),
+                        line_num
+                    );
                 }
             }
         }
@@ -123,13 +136,14 @@ fn parse_cloudflare_line(
 
     let eligible = status_code != 206 && (200..400).contains(&status_code);
 
-    // Origin response time (seconds)
-    let origin_time_ms = v["OriginResponseTime"]
-        .as_f64()
-        .or_else(|| v["OriginResponseHTTPExpires"].as_f64())
-        .unwrap_or(0.0);
-    let latency_ms = if origin_time_ms.is_finite() && (0.0..=3600000.0).contains(&origin_time_ms) {
-        origin_time_ms
+    // OriginResponseTime: nanoseconds in Cloudflare Logpush v2 → convert to ms
+    let origin_time_ns = v["OriginResponseTime"]
+        .as_u64()
+        .or_else(|| v["OriginResponseTime"].as_f64().map(|f| f as u64))
+        .unwrap_or(0);
+    let latency_ms = origin_time_ns as f64 / 1_000_000.0;
+    let latency_ms = if latency_ms.is_finite() && (0.0..=3600000.0).contains(&latency_ms) {
+        latency_ms
     } else {
         0.0
     };

crates/qc-cli/src/providers/fastly.rs

@@ -38,16 +38,23 @@ impl ProviderLogParser for FastlyParser {
         let mut buf = Vec::with_capacity(4096);
         let mut reader = reader;
 
+        let mut line_num = 0usize;
+
         loop {
             buf.clear();
+            line_num += 1;
             let bytes_read = (&mut reader)
                 .take((MAX_LINE_BYTES + 1) as u64)
                 .read_until(b'\n', &mut buf)?;
             if bytes_read == 0 {
                 break;
             }
             if buf.len() > MAX_LINE_BYTES && !buf.ends_with(b"\n") {
-                tracing::warn!("skipping oversized line (>{MAX_LINE_BYTES} bytes)");
+                tracing::warn!(
+                    "{}:{}: skipping oversized line (>{MAX_LINE_BYTES} bytes)",
+                    path.display(),
+                    line_num
+                );
                 loop {
                     buf.clear();
                     let n = (&mut reader)
@@ -61,7 +68,10 @@ impl ProviderLogParser for FastlyParser {
             }
             let line = match std::str::from_utf8(&buf) {
                 Ok(s) => s.trim(),
-                Err(_) => continue,
+                Err(_) => {
+                    tracing::warn!("{}:{}: skipping non-UTF-8 line", path.display(), line_num);
+                    continue;
+                }
             };
             if line.is_empty() {
                 continue;
@@ -71,7 +81,11 @@ impl ProviderLogParser for FastlyParser {
                 Ok(Some(e)) => events.push(e),
                 Ok(None) => {}
                 Err(e) => {
-                    tracing::warn!("skipping malformed line: {e}");
+                    tracing::warn!(
+                        "{}:{}: skipping malformed line: {e}",
+                        path.display(),
+                        line_num
+                    );
                 }
             }
         }
@@ -111,7 +125,8 @@ fn parse_fastly_line(
 
     // URL: may be full request line "GET /path HTTP/1.1" or just "/path"
     let raw_url = v["url"].as_str().unwrap_or("/");
-    let uri = if raw_url.starts_with("GET ") || raw_url.starts_with("POST ") {
+    let uri = if raw_url.contains(' ') {
+        // Request line: "METHOD /path HTTP/version" — extract path component
         raw_url.split_whitespace().nth(1).unwrap_or("/").to_string()
     } else {
         raw_url.to_string()

crates/qc-solver/src/calibrate.rs

@@ -88,7 +88,7 @@ pub fn default_eval(
 pub fn calibrate(
     train_features: &[ObjectFeatures],
     _train_events: &[RequestTraceEvent],
-    val_features: &[ObjectFeatures],
+    _val_features: &[ObjectFeatures],
     val_events: &[RequestTraceEvent],
     base_config: &ScenarioConfig,
     num_restarts: usize,
@@ -166,7 +166,9 @@ pub fn calibrate(
             _ => StalePenaltyClass::Medium,
         };
         let config = make_config(capacity, lat, pen);
-        let score = default_eval(&config, val_features, val_events, capacity)?;
+        // Train on training data, evaluate on validation data (consistent with main loop)
+        let cached_keys = train_policy(&config, train_features, capacity)?;
+        let score = eval_with_keys(&cached_keys, val_events, config.latency_value_per_ms);
         sensitivity.push(("latency_value_per_ms".into(), lat, score - base_score));
     }