mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 15:10:00 +08:00
## Description
`LogCompressor.compress()` runs entirely in Rust. The class still
carried a Python re-implementation of the line parser, scorer, selector,
deduper, context adder and formatter, plus the pytest short-summary
helpers and a `_store_in_ccr` shim. Production never ran them, and
`_store_in_ccr` still had the #816 bug that the live path fixed (no
`explicit_hash`). All removed names are private.
Refs #4136
## Type of Change
- [ ] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Performance improvement
- [x] Code refactoring (no functional changes)
## Changes Made
- Remove the private helpers listed above: about 400 lines.
- Format-detection tests now call `headroom._core.detect_log_format`,
which `compress()` uses.
- Level counts, and the JS and rustc stack-trace shapes, become
`compress()`-level tests. The stack-trace tests run with
`error_context_lines=0`, so only trace detection can keep the frames.
- Two Rust unit tests are added for behaviour no Rust test pinned:
`level_classifier_covers_every_level` (FAIL, DEBUG, TRACE, unknown) and
`score_line_orders_levels_and_boosts`.
- Helper tests whose behaviour Rust already unit-tests are deleted:
dedupe, pytest short-summary recognition and CRLF, the malformed
diagnostic, cap precedence and reservation, omission naming, select
first/last, and the Go/Rust/.NET/Java trace openers.
## Testing
- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [x] Type checking passes (`mypy headroom`)
- [x] New tests added for new functionality
- [ ] Manual testing performed
### Test Output
```text
$ cargo test -p headroom-core --lib log_compressor
test result: ok. 40 passed; 0 failed
$ pytest tests/test_log_compressor.py tests/test_transforms_log_compressor.py tests/test_transforms_stack_traces.py tests/test_ccr_rust_marker_hash_bridge.py tests/test_transforms_content_router.py tests/test_adaptive_sizer.py tests/test_transforms_search_compressor.py tests/test_search_compressor.py
223 passed in 7.52s
$ ruff check / format: All checks passed; mypy log_compressor.py: Success
```
## Real Behavior Proof
- Environment: macOS, Python 3.12, repo `.venv`, this branch's worktree
with the prebuilt `headroom._core`. Temp `HOME`,
`HEADROOM_WORKSPACE_DIR` and `CODEX_HOME`; nothing touched the real
home.
- Exact command / steps: (1) shared smoke harness: a real proxy from
this checkout against a local fake upstream, with one Anthropic and one
OpenAI request carrying a compressible tool result (`smoke.sh
<worktree>`); (2) a real `LogCompressor.compress()` with
`error_context_lines=0` on 100 filler lines, a JS stack trace, and 100
more filler lines.
- Observed result: The proxy serves both requests (200) with the same
savings as main. The direct check keeps exactly the three trace lines
and reports the level counts from Rust. Output below.
- Not tested: Nothing beyond the listed files.
```text
branch: cleanup/transforms-log-drop-python-mirror @ b82ef1b7
health: 200
POST /v1/messages -> HTTP200 smoke-ok
POST /v1/chat/completions -> HTTP200 smoke-ok
stats: requests=2 failed=0 tokens_saved=13574 savings_percent=99.82
proxy.log WARNING/ERROR lines ($SMOKE/ws/logs/proxy-51445.log):
2 headroom.proxy - WARNING - event=proxy_offline_mode air-gap active — every connection Headroom initiates is refused (telemetry, update check, license reporter, model/tokenizer/binary/dataset downloads, remote Kompress, OTLP/Langfuse export, Copilot auth, subscription polling, OpenAI embedders, Headroom Cloud compression). Still allowed on purpose: forwarding your requests to the upstream you configured, operator-configured local endpoints, loopback health probes.
4 headroom.transforms.kompress_compressor - WARNING - Kompress: artifact prefetch found no usable file for chopratejas/kompress-v2-base
4 headroom.transforms.kompress_compressor - WARNING - Kompress: artifact prefetch refused for chopratejas/kompress-v2-base (HEADROOM_OFFLINE is set): HEADROOM_OFFLINE is set: refusing outbound network access for HuggingFace download of chopratejas/kompress-v2-base/onnx/kompress-int8-wo.onnx to huggingface.co. Unset HEADROOM_OFFLINE, or turn off the feature that needs this connection.
(smoke dir: $SMOKE)
```
```text
$ python -c "<LogCompressor(error_context_lines=0).compress(100 filler + JS stack trace + 100 filler)>"
LogFormat.GENERIC {'errors': 1, 'fails': 0, 'info': 0, 'selected': 3, 'total': 203, 'warnings': 0}
Error: Connection failed
at Connection.connect (src/db.js:42:15)
at async main (src/index.js:10:5)
[200 lines omitted: 1 ERROR]
```
## Runtime Rollout Safety
- Rollout-managed feature(s): None.
- Minimum rollout channel: Not applicable; no rollout-managed behaviour
is touched.
- Stable/default behavior changed: No. Only unused private methods are
removed.
- Kill switch / disable path: Not applicable; nothing that runs changes.
- Unsafe override required: No.
- Qualification impact: None.
- Rollback path: Revert this single commit.
## Review Readiness
- [x] I have performed a self-review
- [x] This PR is ready for human review
## Checklist
- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [x] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [x] I did **not** edit `CHANGELOG.md` — it is generated by
release-please from my Conventional Commit PR title (a CI guard enforces
this)
## Screenshots (if applicable)
Not applicable.
## Additional Notes
Part of maintainer-requested cleanup #4136 (dead code, duplication,
debuggability), split into small PRs for review.
Documentation changes are not in this PR. They are recorded in the
cleanup docs ledger for the single follow-up docs PR.
`adaptive_sizer.py` is kept on purpose. On main, the SearchCompressor
helpers still import it, and those are removed in a separate PR. Delete
it in a one-file follow-up once both PRs land.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
156 lines
6.1 KiB
Python
156 lines
6.1 KiB
Python
"""Language-aware stack-trace detection and frame collapse.
|
|
|
|
Covers the new trace flavors (Go panics/goroutine dumps, Rust panics with
|
|
backtraces, .NET inner-exception chains, Java `Caused by:` continuation) and
|
|
the runtime-frame collapse that replaces blind tail truncation for oversized
|
|
traces. The Rust unit tests pin the state-machine behavior; these tests pin
|
|
the Python-visible surface: content detection, the shim's mirrored patterns,
|
|
and end-to-end compression through `LogCompressor`.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import pytest
|
|
|
|
from headroom.transforms.content_detector import ContentType, detect_content_type
|
|
from headroom.transforms.log_compressor import LogCompressor, LogCompressorConfig
|
|
|
|
# Fixtures --------------------------------------------------------------------
|
|
|
|
|
|
def go_panic_dump(goroutines: int = 24) -> str:
|
|
lines = [
|
|
"panic: runtime error: invalid memory address or nil pointer dereference",
|
|
"",
|
|
"[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x4a2b3c]",
|
|
"",
|
|
"goroutine 1 [running]:",
|
|
"main.handler(0xc000010000)",
|
|
"\t/app/cmd/server/main.go:42 +0x1d",
|
|
]
|
|
for g in range(2, goroutines + 2):
|
|
lines += [
|
|
f"goroutine {g} [chan receive]:",
|
|
"runtime.gopark(0x0, 0x0, 0x0, 0x0, 0x0)",
|
|
"\t/usr/local/go/src/runtime/proc.go:381 +0xd6",
|
|
"runtime.chanrecv(0xc00006e0c0, 0x0, 0x1, 0x0)",
|
|
"\t/usr/local/go/src/runtime/chan.go:583 +0x49d",
|
|
"",
|
|
]
|
|
return "\n".join(lines)
|
|
|
|
|
|
def rust_panic_backtrace(frames: int = 20) -> str:
|
|
lines = [
|
|
"thread 'main' panicked at src/main.rs:5:5:",
|
|
"index out of bounds: the len is 3 but the index is 99",
|
|
"stack backtrace:",
|
|
]
|
|
for i in range(frames):
|
|
lines += [
|
|
f" {i}: core::panicking::panic_fmt",
|
|
f" at /rustc/abc123/library/core/src/panicking.rs:{i + 1}:5",
|
|
]
|
|
lines += [" 20: app::run", " at ./src/main.rs:5:5"]
|
|
lines.append("note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace")
|
|
return "\n".join(lines)
|
|
|
|
|
|
def java_chained_trace(runtime_frames: int = 30) -> str:
|
|
lines = ['Exception in thread "main" java.lang.IllegalStateException: boom']
|
|
lines.append("at com.example.App.handle(App.java:10)")
|
|
lines.append("at com.example.App.dispatch(App.java:20)")
|
|
for i in range(runtime_frames):
|
|
lines.append(f"at java.base/java.util.stream.Op{i}.eval(Op{i}.java:{i + 1})")
|
|
lines.append("Caused by: java.io.IOException: disk gone")
|
|
lines.append("at com.example.Disk.read(Disk.java:77)")
|
|
for i in range(runtime_frames):
|
|
lines.append(f"at java.base/java.lang.Thread{i}.run(Thread.java:{i + 1})")
|
|
lines.append("... 17 more")
|
|
return "\n".join(lines)
|
|
|
|
|
|
def dotnet_trace() -> str:
|
|
return "\n".join(
|
|
[
|
|
"Unhandled exception. System.InvalidOperationException: outer failed",
|
|
" ---> System.ArgumentNullException: inner value was null",
|
|
" at App.Data.Load(String path) in /src/App/Data.cs:line 42",
|
|
" --- End of inner exception stack trace ---",
|
|
" at App.Program.Main(String[] args) in /src/App/Program.cs:line 12",
|
|
]
|
|
)
|
|
|
|
|
|
# Detection -------------------------------------------------------------------
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"content",
|
|
[
|
|
go_panic_dump(),
|
|
rust_panic_backtrace(),
|
|
java_chained_trace(),
|
|
# .NET trace padded with neutral build lines to clear line-count floors
|
|
dotnet_trace() + "\n" + "\n".join(f"Restore complete {i}" for i in range(6)),
|
|
],
|
|
ids=["go", "rust", "java", "dotnet"],
|
|
)
|
|
def test_traces_detected_as_build_output(content: str) -> None:
|
|
result = detect_content_type(content)
|
|
assert result.content_type is ContentType.BUILD_OUTPUT
|
|
|
|
|
|
def test_node_async_frames_count_toward_log_detection() -> None:
|
|
content = "\n".join(
|
|
[
|
|
"Error: connect ECONNREFUSED 127.0.0.1:5432",
|
|
" at async Database.connect (/app/src/db.js:14:3)",
|
|
" at async Pool.acquire (/app/src/pool.js:88:9)",
|
|
" at async handleRequest (/app/src/routes.js:31:5)",
|
|
" at async main (/app/src/index.js:5:1)",
|
|
]
|
|
+ [f"request {i} handled" for i in range(10)]
|
|
)
|
|
result = detect_content_type(content)
|
|
assert result.content_type is ContentType.BUILD_OUTPUT
|
|
|
|
|
|
# End-to-end compression --------------------------------------------------------
|
|
|
|
|
|
def test_go_dump_collapses_runtime_frames_keeps_panic_and_app_frame() -> None:
|
|
compressor = LogCompressor(LogCompressorConfig(enable_ccr=False))
|
|
content = go_panic_dump()
|
|
result = compressor.compress(content)
|
|
assert result.compressed_line_count < result.original_line_count
|
|
assert "panic: runtime error" in result.compressed
|
|
assert "main.handler" in result.compressed # the app frame
|
|
assert "frames collapsed]" in result.compressed
|
|
# The runtime scheduler noise does not dominate the output.
|
|
assert result.compressed.count("runtime.gopark") <= 2
|
|
|
|
|
|
def test_java_chain_heads_survive_collapse() -> None:
|
|
compressor = LogCompressor(LogCompressorConfig(enable_ccr=False, min_lines_for_ccr=10))
|
|
result = compressor.compress(java_chained_trace())
|
|
assert "Caused by: java.io.IOException" in result.compressed
|
|
assert "com.example.Disk.read" in result.compressed
|
|
assert "... 17 more" in result.compressed
|
|
assert "frames collapsed]" in result.compressed
|
|
|
|
|
|
def test_collapse_can_be_disabled() -> None:
|
|
compressor = LogCompressor(LogCompressorConfig(enable_ccr=False, collapse_runtime_frames=False))
|
|
result = compressor.compress(go_panic_dump())
|
|
assert "frames collapsed]" not in result.compressed
|
|
|
|
|
|
def test_collapse_config_plumbs_through() -> None:
|
|
# Constructor accepts the new knobs and forwards them to Rust without error.
|
|
compressor = LogCompressor(
|
|
LogCompressorConfig(trace_head_frames=1, trace_app_frames=2, enable_ccr=False)
|
|
)
|
|
result = compressor.compress(go_panic_dump())
|
|
assert result.compressed # smoke: no TypeError from the PyO3 signature
|