Retrieve requestline info even when header parsing failed

[Keksoj]

for now, if header parsing fails, we return a 400, but the access log does not indicate method, authority or path, which is information available in the request line.

Kawa should be fixed in that sense, then Sōzu make use of this change.

[FlorentinDUBOIS]

Confirming the gap is still there in main (against kawa 0.6.8). The reason Answer400's access log carries no method/authority/path is that the only place sozu populates HttpContext.method/authority/path is HttpContext::on_request_headers (lib/src/protocol/kawa_h1/editor.rs:384-404), and that sozu callback is wired through kawa::h1::ParserCallbacks::on_headers. Kawa only invokes on_headers after process_headers() succeeds (kawa-0.6.8 src/protocol/h1/parser/mod.rs:405), so the Error branch in Http::readable (lib/src/protocol/kawa_h1/mod.rs:494) calls set_answer(DefaultAnswer::Answer400 { … }) with the three context fields still None. The access log emitter at mod.rs:957-965/1022 then renders an empty EndpointRecord::Http.

Kawa side (smallest viable change) — extend ParserCallbacks with a hook that fires earlier than on_headers:

pub trait ParserCallbacks<T: AsBuffer> {
    fn on_request_line(&mut self, _kawa: &mut Kawa<T>) {} // new
    fn on_headers(&mut self, _kawa: &mut Kawa<T>) {}
}

Invoke it once, between kawa.blocks.push_back(Block::StatusLine) and the phase transition (parser/mod.rs:218-219), i.e. as soon as parse_request_line populated method/uri/version. At that point authority and path are still Store::Empty (they get filled by process_headers's parse_url call), so consumers either read the raw uri slice or call kawa::h1::parser::primitives::parse_url themselves — parse_url is already pub, so no new surface needed if you'd rather skip a callback and just expose a Kawa::status_line() accessor that's safe to read in the ParsingPhase::Error state.

If only the request line itself fails to parse, detached.status_line stays StatusLine::Unknown — nothing recoverable, the access log line just keeps the empty fields. Worth documenting that this is by design.

Sozu side — once kawa exposes the early hook:

1. Factor the capture block (editor.rs:384-404) into a small capture_request_line(&mut self, request: &GenericHttpStream) helper.
2. Implement on_request_line on HttpContext to call that helper plus parse_url(buf, method, uri) so self.path and (when the URI is absolute) self.authority are filled before the headers are attempted. Don't move any of the other work in on_request_headers — sticky-cookie elision, X-Forwarded-* edits, x-request-id derivation must still gate on a complete header set.
3. In the parse-error branch (kawa_h1/mod.rs:494), no further wiring is required: the access log path (log_request → log_endpoint) reads self.context.{method,authority,path} directly, so the fields surface as soon as they're populated.

Watchpoints worth not skipping in the PR:

• Don't back-fill authority from a Host header that hasn't been validated. With a header-parse failure, the Block::Header entries we see may include attacker-shaped values; only trust the URI's authority component when it's absolute, otherwise leave authority = None.
• Log-line escaping. EndpointRecord::Http already filters non-UTF-8 (data_opt(...).and_then(|d| from_utf8(d).ok())), but a malformed-but-valid-UTF-8 method or path containing CR/LF/quote can still hit the access-log writer. Confirm the formatter escapes control bytes before merging — otherwise a parse-error line becomes a log-injection vector now that we're emitting attacker-controlled bytes there.
• Tolerant parser (tolerant-http1-parser) doesn't change the callback shape, only the kinds of inputs that survive — the new hook works the same way.
• H2 mux has a structurally similar gap (mux/pkawa.rs rejects bad pseudo-headers via H2Error → RST_STREAM with no method/path on the access log either), but the mechanism is different and the fix has a different shape — better as a separate issue than folded into this one.
• Metric: the http.frontend_parse_errors counter at mod.rs:495 already fires; nothing to add there.

[FlorentinDUBOIS]

Correction to my 2026-05-02 comment above. #1551 fixed this issue without the kawa change that comment proposed.

• No new ParserCallbacks hook was needed. kawa 0.7.1 parses the request line before the headers and keeps it in the public Kawa::detached.status_line after a header failure. parse_url is public as well.
• The fix lives in the mux H1 path, not in kawa_h1/editor.rs. Stream::generate_access_log (lib/src/protocol/mux/stream.rs) calls a new rejected_request_line when the front is in error and the context never captured a method. That function borrows the method, path and authority from the front buffer with zero allocation.
• The authority is never taken from a Host line. It is logged only when the request uses an absolute-form URI. This follows the watchpoint above.
• A request whose request line itself is invalid still logs - - - 400, as that comment predicted.

The H2 gap mentioned in the watchpoints is not covered by #1551.