fixtura 1.0.0__tar.gz

fixtura-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yashrajsinh Rathod
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fixtura-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+exclude .agents/AGENTS.md
+recursive-exclude tests *
+recursive-exclude .github *

fixtura-1.0.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: fixtura
+Version: 1.0.0
+Summary: Deterministic execution recording and replay for AI agents
+Author: Yashrajsinh Rathod
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic<3.0,>=2.0
+Requires-Dist: requests<3.0,>=2.0
+Requires-Dist: zstandard<1.0,>=0.20
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: types-requests>=2.0; extra == "dev"
+Dynamic: license-file
+
+# Fixtura
+
+**Deterministic execution recording and replay for AI agents — turn real agent runs into regression tests.**
+
+## What this is
+
+Fixtura watches an AI agent's tool calls (filesystem, database, API, etc.), records everything that happens through a permission-checked execution layer, and lets you replay that recording later — deterministically, without touching live systems — to debug failures or gate CI on regressions.
+
+It's built to work with **OpenEval**, a deterministic (non-LLM-judge) agent evaluation engine already built and published separately. Fixtura produces the recordings; OpenEval scores them.
+
+## Why this exists
+
+Most "agent observability" tools (Langfuse, Phoenix, Braintrust, Laminar) are built for production monitoring at scale. Fixtura's angle is narrower and more testable: **recorded traces as literal test fixtures**, replayable offline, usable to gate pull requests the same way unit test snapshots do. See ARCHITECTURE.md for why this is scoped the way it is, and what was deliberately cut.
+
+## Status
+
+✅ v1.0.0 is released. See ROADMAP.md for future features like counterfactual replay (Live Branching).
+
+## OpenEval Adapter (optional, manual install required)
+
+The OpenEval evaluation harness (Acceptance Test 4) relies on OpenEval, which is currently unpublished on PyPI. Note that the openeval namespace on PyPI is occupied by an unrelated placeholder package. 
+
+To use the OpenEval Adapter, you must manually install OpenEval via git:
+`ash
+pip install git+https://github.com/yash161004/OpenEval.git@4cb6cfe362c770a7674f5b0111ff54646883709b
+`
+Without this, pip install fixtura will give you the core recording, permissions, and replay capabilities, but importing ixtura.tools.openeval_adapter will raise a clear RuntimeError prompting this manual installation.
+
+## Documents in this repo
+
+| Doc | Purpose |
+|---|---|
+| ARCHITECTURE.md | System design, components, data flow |
+| THREAT_MODEL.md | Trust boundaries, what could go wrong, mitigations |
+| ROADMAP.md | Frozen v1 scope table + acceptance tests + v1.1/v2 future work |
+| docs/TRACE_FORMAT_SPEC.md | Exact schema every recording must produce |
+| docs/COLLABORATION.md | How the owner, Claude, ChatGPT, and Antigravity work together on this project |
+
+## Core components
+
+1. Tool Execution Layer
+2. Permission Engine
+3. Execution Recorder + Sanitizer
+4. Passive Replay + Step Inspection
+5. Trace Viewer UI (minimal)
+6. OpenEval adapter (evaluation harness reuse)
+
+## License
+
+[MIT License](LICENSE)

fixtura-1.0.0/README.md

@@ -0,0 +1,50 @@
+# Fixtura
+
+**Deterministic execution recording and replay for AI agents — turn real agent runs into regression tests.**
+
+## What this is
+
+Fixtura watches an AI agent's tool calls (filesystem, database, API, etc.), records everything that happens through a permission-checked execution layer, and lets you replay that recording later — deterministically, without touching live systems — to debug failures or gate CI on regressions.
+
+It's built to work with **OpenEval**, a deterministic (non-LLM-judge) agent evaluation engine already built and published separately. Fixtura produces the recordings; OpenEval scores them.
+
+## Why this exists
+
+Most "agent observability" tools (Langfuse, Phoenix, Braintrust, Laminar) are built for production monitoring at scale. Fixtura's angle is narrower and more testable: **recorded traces as literal test fixtures**, replayable offline, usable to gate pull requests the same way unit test snapshots do. See ARCHITECTURE.md for why this is scoped the way it is, and what was deliberately cut.
+
+## Status
+
+✅ v1.0.0 is released. See ROADMAP.md for future features like counterfactual replay (Live Branching).
+
+## OpenEval Adapter (optional, manual install required)
+
+The OpenEval evaluation harness (Acceptance Test 4) relies on OpenEval, which is currently unpublished on PyPI. Note that the openeval namespace on PyPI is occupied by an unrelated placeholder package. 
+
+To use the OpenEval Adapter, you must manually install OpenEval via git:
+`ash
+pip install git+https://github.com/yash161004/OpenEval.git@4cb6cfe362c770a7674f5b0111ff54646883709b
+`
+Without this, pip install fixtura will give you the core recording, permissions, and replay capabilities, but importing ixtura.tools.openeval_adapter will raise a clear RuntimeError prompting this manual installation.
+
+## Documents in this repo
+
+| Doc | Purpose |
+|---|---|
+| ARCHITECTURE.md | System design, components, data flow |
+| THREAT_MODEL.md | Trust boundaries, what could go wrong, mitigations |
+| ROADMAP.md | Frozen v1 scope table + acceptance tests + v1.1/v2 future work |
+| docs/TRACE_FORMAT_SPEC.md | Exact schema every recording must produce |
+| docs/COLLABORATION.md | How the owner, Claude, ChatGPT, and Antigravity work together on this project |
+
+## Core components
+
+1. Tool Execution Layer
+2. Permission Engine
+3. Execution Recorder + Sanitizer
+4. Passive Replay + Step Inspection
+5. Trace Viewer UI (minimal)
+6. OpenEval adapter (evaluation harness reuse)
+
+## License
+
+[MIT License](LICENSE)

fixtura-1.0.0/cli/__init__.py

@@ -0,0 +1 @@
+# Init file

fixtura-1.0.0/cli/eval.py

@@ -0,0 +1,42 @@
+import os
+from pprint import pprint
+
+from tools.openeval_adapter import trace_to_agent_trace
+from openeval.runner import run_eval
+from openeval.models import EvalTestCase
+from openeval.metrics import ToolSelectionAccuracy, ArgumentCorrectness, StepEfficiency, GoalCompletionRate
+
+def run(trace_path: str) -> None:
+    print(f"Scoring {trace_path} via OpenEval adapter...")
+    metrics = [
+        ToolSelectionAccuracy(),
+        ArgumentCorrectness(),
+        StepEfficiency(),
+        GoalCompletionRate()
+    ]
+    
+    # We match the test case against the fixture agent built in cli.record
+    tc = EvalTestCase(
+        task_id="canonical-task",
+        input="Do stuff",
+        expected_tool_calls=[
+            {"tool": "filesystem_tool", "args": {"operation": "read", "path": "wrong_path.txt"}},
+            {"tool": "sqlite_tool", "args": {"operation": "read", "query": "SELECT * FROM test"}},
+            {"tool": "http_tool", "args": {"url": "http://disallowed.com"}}
+        ],
+        expected_final_state={},
+        expected_output_contains=[],
+        max_steps=5,
+        timeout_seconds=10.0
+    )
+    
+    trace = trace_to_agent_trace(
+        trace_path=trace_path,
+        task_id="canonical-task",
+        input_text="Do stuff",
+        final_output="Done",
+        actual_state={}
+    )
+    
+    res = run_eval(trace, tc, metrics)
+    pprint(res)

fixtura-1.0.0/cli/html_view.py

@@ -0,0 +1,7 @@
+import sys
+from tools import html_viewer
+
+def run(trace_path: str) -> None:
+    # Hijack sys.argv so argparse in html_viewer.main() works
+    sys.argv = ["fixtura html-view", trace_path]
+    html_viewer.main()

fixtura-1.0.0/cli/inspect.py

@@ -0,0 +1,18 @@
+from replay.step_inspector import StepInspector
+from pprint import pprint
+
+def run(trace_path: str) -> None:
+    print(f"Running Step Inspector for {trace_path}...")
+    inspector = StepInspector(trace_path)
+    step = 1
+    while inspector.advance():
+        current = inspector.current_step()
+        print(f"\n--- Paused at Step {step} ---")
+        pprint(current)
+        try:
+            input("Press Enter to continue to next step...")
+        except EOFError:
+            print("\nInspection ended: no more input available.")
+            break
+        step += 1
+    print("\nReached end of trace.")

fixtura-1.0.0/cli/main.py

@@ -0,0 +1,52 @@
+import argparse
+import sys
+
+from cli import record, replay, inspect, view, eval, html_view
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Fixtura CLI")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    
+    # Record
+    parser_record = subparsers.add_parser("record", help="Record a trace using the canonical test agent")
+    parser_record.add_argument("trace_file", help="Path to output trace file")
+    
+    # Replay
+    parser_replay = subparsers.add_parser("replay", help="Passively replay a trace")
+    parser_replay.add_argument("trace_file", help="Path to input trace file")
+    
+    # Inspect
+    parser_inspect = subparsers.add_parser("inspect", help="Step-inspect a trace interactively")
+    parser_inspect.add_argument("trace_file", help="Path to input trace file")
+    
+    # View
+    parser_view = subparsers.add_parser("view", help="View a trace summary")
+    parser_view.add_argument("trace_file", help="Path to input trace file")
+    
+    # Eval
+    parser_eval = subparsers.add_parser("eval", help="Score a trace via OpenEval adapter")
+    parser_eval.add_argument("trace_file", help="Path to input trace file")
+    
+    # HTML View
+    parser_html_view = subparsers.add_parser("html-view", help="View a trace summary in HTML format")
+    parser_html_view.add_argument("trace_file", help="Path to input trace file")
+
+    args = parser.parse_args()
+    
+    if args.command == "record":
+        record.run(args.trace_file)
+    elif args.command == "replay":
+        replay.run(args.trace_file)
+    elif args.command == "inspect":
+        inspect.run(args.trace_file)
+    elif args.command == "view":
+        view.run(args.trace_file)
+    elif args.command == "eval":
+        eval.run(args.trace_file)
+    elif args.command == "html-view":
+        html_view.run(args.trace_file)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

fixtura-1.0.0/cli/record.py

@@ -0,0 +1,103 @@
+import os
+import sqlite3
+
+from security.permission_engine import CapabilityToken
+from security.rate_limiter import RateLimiter
+from recorder.recorder import ExecutionRecorder
+from tools.filesystem_tool import FilesystemTool
+from tools.sqlite_tool import SqliteTool
+from tools.http_tool import HttpTool
+
+def run(trace_path: str) -> None:
+    print(f"Recording canonical test trace to {trace_path}...")
+    
+    if os.path.exists(trace_path):
+        os.remove(trace_path)
+        
+    recorder = ExecutionRecorder(trace_path)
+    
+    token = CapabilityToken()
+    token.filesystem.read = [os.getcwd()]
+    token.filesystem.write = [os.getcwd()]
+    token.http.allowed_domains = ["example.com"]
+    # No DB permissions given
+    
+    rate_limiter = RateLimiter()
+    
+    fs_tool = FilesystemTool(sandbox_root=os.getcwd())
+    
+    db_path = "test.db"
+    with sqlite3.connect(db_path) as conn:
+        conn.execute("CREATE TABLE IF NOT EXISTS test (id INTEGER)")
+    db_tool = SqliteTool(db_path=db_path)
+    
+    http_tool = HttpTool()
+    
+    # 1. LLM Step
+    recorder.record_event({
+        "event_type": "llm_call",
+        "timestamp": 100.0,
+        "prompt": "Read the local file",
+        "completion": "I'll use filesystem tool",
+        "provider": "test",
+        "model": "test",
+        "input_tokens": 10,
+        "output_tokens": 10,
+        "finish_reason": "stop",
+        "latency_ms": 100
+    })
+    
+    # 2. FS Tool (Should be allowed)
+    with open("test.txt", "w") as f:
+        f.write("test_content secret-sk-12345678901234567890")
+    
+    args = {"operation": "read", "path": os.path.abspath("test.txt")}
+    res = fs_tool.execute(token, args, rate_limiter=rate_limiter)
+    recorder.record_event({
+        "event_type": "tool_call",
+        "timestamp": 200.0,
+        "tool_name": "filesystem_tool",
+        "arguments": args,
+        "permission_decision": "allowed" if res.outcome not in ("permission_denied", "validation_error") else "denied",
+        "permission_reason": res.reason if res.outcome == "permission_denied" else None,
+        "rate_limit_decision": "rate_limited" if res.outcome == "rate_limited" else ("circuit_broken" if res.outcome == "circuit_broken" else "allowed"),
+        "rate_limit_reason": res.reason if res.outcome in ("rate_limited", "circuit_broken") else None,
+        "response": res.result,
+        "latency_ms": 50
+    })
+        
+    # 3. DB Tool (Should be denied)
+    args = {"operation": "read", "query": "SELECT * FROM test"}
+    res = db_tool.execute(token, args, rate_limiter=rate_limiter)
+    recorder.record_event({
+        "event_type": "tool_call",
+        "timestamp": 300.0,
+        "tool_name": "sqlite_tool",
+        "arguments": args,
+        "permission_decision": "allowed" if res.outcome not in ("permission_denied", "validation_error") else "denied",
+        "permission_reason": res.reason if res.outcome == "permission_denied" else None,
+        "rate_limit_decision": "rate_limited" if res.outcome == "rate_limited" else ("circuit_broken" if res.outcome == "circuit_broken" else "allowed"),
+        "rate_limit_reason": res.reason if res.outcome in ("rate_limited", "circuit_broken") else None,
+        "response": res.result,
+        "latency_ms": 50
+    })
+
+    # 4. HTTP Tool (Should be denied because we pass a disallowed URL to trigger another denial, 
+    # or we can pass an allowed one. The prompt says "at least one allowed and one denied". 
+    # I'll pass a denied one to match the OpenEval adapter test expectation of missing tools)
+    args = {"url": "http://disallowed.com"}
+    res = http_tool.execute(token, args, rate_limiter=rate_limiter)
+    recorder.record_event({
+        "event_type": "tool_call",
+        "timestamp": 400.0,
+        "tool_name": "http_tool",
+        "arguments": args,
+        "permission_decision": "allowed" if res.outcome not in ("permission_denied", "validation_error") else "denied",
+        "permission_reason": res.reason if res.outcome == "permission_denied" else None,
+        "rate_limit_decision": "rate_limited" if res.outcome == "rate_limited" else ("circuit_broken" if res.outcome == "circuit_broken" else "allowed"),
+        "rate_limit_reason": res.reason if res.outcome in ("rate_limited", "circuit_broken") else None,
+        "response": res.result,
+        "latency_ms": 50
+    })
+    
+    print("Trace recording complete!")

fixtura-1.0.0/cli/replay.py

@@ -0,0 +1,8 @@
+from replay.passive_replay import PassiveReplay
+from pprint import pprint
+
+def run(trace_path: str) -> None:
+    print(f"Running Passive Replay for {trace_path}...")
+    replay = PassiveReplay(trace_path)
+    for step_result in replay.run():
+        pprint(step_result)

fixtura-1.0.0/cli/view.py

@@ -0,0 +1,7 @@
+import sys
+from tools import viewer
+
+def run(trace_path: str) -> None:
+    # Hijack sys.argv so argparse in viewer.main() works
+    sys.argv = ["fixtura view", trace_path]
+    viewer.main()

fixtura-1.0.0/fixtura.egg-info/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: fixtura
+Version: 1.0.0
+Summary: Deterministic execution recording and replay for AI agents
+Author: Yashrajsinh Rathod
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic<3.0,>=2.0
+Requires-Dist: requests<3.0,>=2.0
+Requires-Dist: zstandard<1.0,>=0.20
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: types-requests>=2.0; extra == "dev"
+Dynamic: license-file
+
+# Fixtura
+
+**Deterministic execution recording and replay for AI agents — turn real agent runs into regression tests.**
+
+## What this is
+
+Fixtura watches an AI agent's tool calls (filesystem, database, API, etc.), records everything that happens through a permission-checked execution layer, and lets you replay that recording later — deterministically, without touching live systems — to debug failures or gate CI on regressions.
+
+It's built to work with **OpenEval**, a deterministic (non-LLM-judge) agent evaluation engine already built and published separately. Fixtura produces the recordings; OpenEval scores them.
+
+## Why this exists
+
+Most "agent observability" tools (Langfuse, Phoenix, Braintrust, Laminar) are built for production monitoring at scale. Fixtura's angle is narrower and more testable: **recorded traces as literal test fixtures**, replayable offline, usable to gate pull requests the same way unit test snapshots do. See ARCHITECTURE.md for why this is scoped the way it is, and what was deliberately cut.
+
+## Status
+
+✅ v1.0.0 is released. See ROADMAP.md for future features like counterfactual replay (Live Branching).
+
+## OpenEval Adapter (optional, manual install required)
+
+The OpenEval evaluation harness (Acceptance Test 4) relies on OpenEval, which is currently unpublished on PyPI. Note that the openeval namespace on PyPI is occupied by an unrelated placeholder package. 
+
+To use the OpenEval Adapter, you must manually install OpenEval via git:
+`ash
+pip install git+https://github.com/yash161004/OpenEval.git@4cb6cfe362c770a7674f5b0111ff54646883709b
+`
+Without this, pip install fixtura will give you the core recording, permissions, and replay capabilities, but importing ixtura.tools.openeval_adapter will raise a clear RuntimeError prompting this manual installation.
+
+## Documents in this repo
+
+| Doc | Purpose |
+|---|---|
+| ARCHITECTURE.md | System design, components, data flow |
+| THREAT_MODEL.md | Trust boundaries, what could go wrong, mitigations |
+| ROADMAP.md | Frozen v1 scope table + acceptance tests + v1.1/v2 future work |
+| docs/TRACE_FORMAT_SPEC.md | Exact schema every recording must produce |
+| docs/COLLABORATION.md | How the owner, Claude, ChatGPT, and Antigravity work together on this project |
+
+## Core components
+
+1. Tool Execution Layer
+2. Permission Engine
+3. Execution Recorder + Sanitizer
+4. Passive Replay + Step Inspection
+5. Trace Viewer UI (minimal)
+6. OpenEval adapter (evaluation harness reuse)
+
+## License
+
+[MIT License](LICENSE)

fixtura-1.0.0/fixtura.egg-info/SOURCES.txt

@@ -0,0 +1,37 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+cli/__init__.py
+cli/eval.py
+cli/html_view.py
+cli/inspect.py
+cli/main.py
+cli/record.py
+cli/replay.py
+cli/view.py
+fixtura.egg-info/PKG-INFO
+fixtura.egg-info/SOURCES.txt
+fixtura.egg-info/dependency_links.txt
+fixtura.egg-info/entry_points.txt
+fixtura.egg-info/requires.txt
+fixtura.egg-info/top_level.txt
+recorder/__init__.py
+recorder/recorder.py
+recorder/sanitizer.py
+recorder/trace_reader.py
+replay/__init__.py
+replay/passive_replay.py
+replay/step_inspector.py
+security/__init__.py
+security/permission_engine.py
+security/rate_limiter.py
+tools/__init__.py
+tools/base.py
+tools/base_tool.py
+tools/filesystem_tool.py
+tools/html_viewer.py
+tools/http_tool.py
+tools/openeval_adapter.py
+tools/sqlite_tool.py
+tools/viewer.py

fixtura-1.0.0/fixtura.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fixtura-1.0.0/fixtura.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fixtura = cli.main:main

fixtura-1.0.0/fixtura.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pydantic<3.0,>=2.0
+requests<3.0,>=2.0
+zstandard<1.0,>=0.20
+
+[dev]
+pytest>=7.0
+mypy>=1.0
+types-requests>=2.0

fixtura-1.0.0/fixtura.egg-info/top_level.txt

@@ -0,0 +1,5 @@
+cli
+recorder
+replay
+security
+tools

fixtura-1.0.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fixtura"
+version = "1.0.0"
+description = "Deterministic execution recording and replay for AI agents"
+authors = [
+    {name = "Yashrajsinh Rathod"}
+]
+readme = {file = "README.md", content-type = "text/markdown"}
+license = {text = "MIT"}
+dependencies = [
+    "pydantic>=2.0,<3.0",
+    "requests>=2.0,<3.0",
+    "zstandard>=0.20,<1.0",
+]
+requires-python = ">=3.11"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "mypy>=1.0",
+    "types-requests>=2.0",
+]
+
+[project.scripts]
+fixtura = "cli.main:main"
+
+[tool.setuptools]
+packages = ["recorder", "replay", "security", "tools", "cli"]
+
+[tool.mypy]
+strict = true
+
+[[tool.mypy.overrides]]
+module = "openeval.*"
+ignore_missing_imports = true

fixtura-1.0.0/recorder/__init__.py

@@ -0,0 +1 @@
+# Init file for recorder package

fixtura-1.0.0/recorder/recorder.py

@@ -0,0 +1,36 @@
+import json
+import threading
+import zstandard as zstd
+from typing import Dict, Any, Union
+from pathlib import Path
+from recorder.sanitizer import Sanitizer
+
+class ExecutionRecorder:
+    def __init__(self, trace_file: Union[str, Path]) -> None:
+        self.trace_file = Path(trace_file)
+        self.sanitizer = Sanitizer()
+        self._lock = threading.Lock()
+        self._step_counter = 1
+
+    def record_event(self, event: Dict[str, Any]) -> None:
+        """
+        Sanitizes and records a single event to the .trace file.
+        No code path is allowed to bypass the sanitizer per TRACE_FORMAT_SPEC.md.
+        """
+        with self._lock:
+            # Overwrite any incoming step_id with our monotonic generator
+            event["step_id"] = f"step-{self._step_counter:06d}"
+            self._step_counter += 1
+            
+            # Pass through the sanitizer pipeline
+            sanitized_event = self.sanitizer.sanitize(event)
+            
+            # Serialize to JSONL string
+            line = json.dumps(sanitized_event) + "\n"
+            
+            # Instantiate compressor locally to avoid shared mutable state
+            cctx = zstd.ZstdCompressor()
+            compressed_frame = cctx.compress(line.encode("utf-8"))
+            
+            with open(self.trace_file, "ab") as f:
+                f.write(compressed_frame)