posthog 7.70.2

Source: https://github.com/posthog/posthog-python
Tag scanned: posthog-v7.70.2
Compared with: posthog-v7.70.1 (0 signals introduced since)
Files: 427 scanned, 274 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 2 warn · 8 info
Scan time: 9.2 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 9 of 9 warn and critical signals; 7 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-15 18:13

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

warn dynamic-execution examples/example-ai-openai-agents/multi_agent.py:29:23

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        return "Error: invalid characters"
    return f"Result: {eval(expression.replace('^', '**'))}"
```
suspicious LLM, confidence 0.60 A calculator tool in an agent example passes a user-influenced expression to eval after replacing '^' with '**'.
Reasoning
eval runs on an expression string that the snippet only partly constrains (a character check is visible, the rest is not). The input may come from an LLM or user, so this is a real code-injection risk in an example, but there is no sign of malicious intent or hidden obfuscation.
warn dynamic-execution examples/example-ai-openai-agents/single_agent.py:29:23

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        return "Error: invalid characters"
    return f"Result: {eval(expression.replace('^', '**'))}"
```
suspicious LLM, confidence 0.60 A single-agent calculator example evaluates a user-influenced expression with eval after a character check.
Reasoning
Same eval-on-expression pattern as multi_agent.py, with the same partial input validation. It is an unsafe example pattern rather than evidence of malice.
info ~~warn~~ → info by review frame-introspection posthog/exception_utils.py:1060:21

`sys._getframe` — call-stack frame introspection (ast pass, confidence 0.70)
```
        try:
            frame = sys._getframe(depth)
            depth += 1
        except ValueError:
```
likely benign LLM, confidence 0.90 Walks the call stack by depth to collect frame information for exception reporting.
Reasoning
sys._getframe in a loop with a ValueError guard is standard stack walking used to build exception or frame metadata. It is ordinary introspection in an error-reporting library.
info ~~warn~~ → info by review encoding-base64 posthog/test/mcp/test_session_token.py:68:15

base64-like blob (95 bytes, compression ratio 1.12) (raw pass, confidence 0.60)
```
    )
    frozen = "eyJzaWQiOiJzZXNfZml4dHVyZSIsImNuIjoiQ2xhdWRlIENvZGUiLCJjdiI6IjEuMi4zIiwicHYiOiIyMDI1LTA2LTE4In0"

    # Encode side: our output is byte-identical to the shared wire format.
```
likely benign LLM, confidence 0.92 A base64-encoded session token fixture in a unit test for the shared wire format.
Reasoning
The base64 string decodes to a readable JSON-like session payload (sid, cn, cv, pv). It is a fixed test fixture for a wire-format round-trip test, not a hidden payload.
info ~~warn~~ → info by review decoder-decompress-payload posthog/test/test_capture_v1.py:456:24

file imports decoder module(s) zlib and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
        self.assertEqual(call["data"][0], 0x78)  # zlib header
        roundtripped = zlib.decompress(call["data"]).decode("utf-8")
        self.assertNotIn("api_key", json.loads(roundtripped))
```
likely benign LLM, confidence 0.93 A test decompresses a captured zlib request body to verify its contents.
Reasoning
zlib.decompress is applied to a captured request body in a test that then checks for the absence of api_key. This is test-side verification of a compressed payload, not runtime execution of an embedded payload.
info ~~warn~~ → info by review decoder-decompress-payload posthog/test/test_metrics.py:55:23

file imports decoder module(s) gzip and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
    body = kwargs.get("data")
    return json.loads(gzip.decompress(body).decode("utf-8"))
```
likely benign LLM, confidence 0.93 A test helper gunzips a mocked request body and parses it as JSON.
Reasoning
gzip.decompress reads the body of a mocked HTTP request so the test can parse the JSON. It is test plumbing with no execution of decoded content.
info ~~warn~~ → info by review decoder-decompress-payload posthog/test/test_request.py:227:27

file imports decoder module(s) gzip, zlib and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
        self.assertEqual(headers["Content-Encoding"], "gzip")
        body = json.loads(gzip.decompress(data))
        self.assertEqual(body["batch"], [])
        self.assertEqual(body["api_key"], TEST_API_KEY)
```
likely benign LLM, confidence 0.93 A test gunzips a captured request body and asserts on its contents.
Reasoning
gzip.decompress on the captured request data is followed by assertions on the batch and API key. This is ordinary test verification of the outgoing payload.
info ~~warn~~ → info by review decoder-decompress-payload posthog/test/tracing/test_client_traces.py:60:23

file imports decoder module(s) gzip and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
    args, kwargs = session.post.call_args
    return json.loads(gzip.decompress(kwargs["data"])), args[0], kwargs
```
likely benign LLM, confidence 0.93 A tracing test helper decompresses and parses a mocked outgoing request body.
Reasoning
The helper gunzips and parses a mocked session.post body for test assertions. The decoded data is only parsed as JSON, never executed.
info ~~warn~~ → info by review decoder-decompress-payload posthog/test/tracing/test_transport.py:71:27

file imports decoder module(s) gzip and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
        assert kwargs["headers"]["Content-Type"] == "application/json"
        assert json.loads(gzip.decompress(kwargs["data"])) == PAYLOAD

    def test_falls_back_to_the_default_timeout(self):
```
likely benign LLM, confidence 0.93 A transport test checks that the gzip-compressed request body matches the expected payload.
Reasoning
gzip.decompress of the request data is compared against an expected payload in a test assertion. This is standard test verification.

info long-line references/public_api_snapshot.txt:1208:1

line length 1545 characters (raw pass, confidence 0.50)

class posthog.client.Client(project_api_key: str, host=None, debug=False, max_queue_size=10000, send=True, on_error=None, flush_at=100, flush_interval=5.0, gzip=False, max_retries=3, sync_mode=False, timeout=15, thread=1, poll_interval=30, personal_api_key=None, disabled=False, disable_geoip=True, is_server=True, histo

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.0.0
git clone https://github.com/posthog/posthog-python posthog-python && cd posthog-python
git checkout posthog-v7.70.2
disclude scan --severity info --diff posthog-v7.70.1 .