Files
headroom/tests/test_transforms_stack_traces.py
Tejas ChopraandClaude Opus 5.5 a20c76c26b refactor(transforms): drop the Python mirror of the Rust log selector (#4096)
## 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>
2026-10-10 08:58:41 -07:00

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