posthog 7.71.0

Source: https://github.com/posthog/posthog-python
Tag scanned: posthog-v7.71.0
Compared with: posthog-v7.70.2 (0 signals introduced since)
Files: 429 scanned, 275 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 2 warn · 8 info
Scan time: 9.8 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-16 21:41

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('^', '**'))}"
```
likely benign LLM, confidence 0.60 A calculator tool in an example agent evaluates a validated arithmetic expression with eval.
Reasoning
eval runs on an expression the LLM agent supplies, which is a real code-injection risk if the character filter is weak. The snippet shows an 'invalid characters' check before the eval, so the input is at least partly filtered. This is example code, not a dropper or obfuscated payload.
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('^', '**'))}"
```
likely benign LLM, confidence 0.60 A single-agent example evaluates a validated arithmetic expression with eval.
Reasoning
This is the same calculator eval pattern as multi_agent.py, with the same character validation before it. It is a demo-level weakness that a careful reviewer would flag, not evidence of malicious intent.
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 call-stack frames to collect context for exception reporting.
Reasoning
sys._getframe(depth) in a loop with a ValueError guard is a standard way to walk the stack for exception-context reporting. Nothing here is hidden or exfiltrating.
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.90 A base64url test fixture encoding a small JSON session token.
Reasoning
The string is a base64url-encoded JSON object with session fields and a client version. It is a fixed test fixture used to check wire-format compatibility, 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.95 A test decompresses a captured request body to assert on its contents.
Reasoning
zlib.decompress here round-trips a request body the test itself captured, then checks that api_key is absent. This is test verification, not runtime payload execution.
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.95 A test helper decompresses a mocked gzip request body to parse its JSON.
Reasoning
gzip.decompress is applied to a mocked request body inside a test helper that parses the JSON for assertions. It is ordinary test plumbing.
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.95 A request test decompresses captured gzip data to check the batch and key fields.
Reasoning
gzip.decompress is applied to captured request data, and the test then asserts on the batch and api_key fields. This is expected behavior for an HTTP client test.
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.95 A tracing test decompresses a mocked POST body to inspect the sent JSON.
Reasoning
gzip.decompress of a mocked session.post payload is parsed for assertions in a tracing test. Nothing executes the decompressed data.
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.95 A transport test decompresses a mocked body and compares it to an expected payload.
Reasoning
gzip.decompress of a mocked request body is compared to a known PAYLOAD in a transport test. This is routine verification of serialization.

info long-line references/public_api_snapshot.txt:1211: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.71.0
disclude scan --severity info --diff posthog-v7.70.2 .