posthog 7.75.2

Source: https://github.com/posthog/posthog-python
Tag scanned: posthog-v7.75.2
Compared with: posthog-v7.75.1 (0 signals introduced since)
Files: 441 scanned, 284 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 10 info
Scan time: 10.3 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 9 of 9 warn and critical signals; 9 demoted to info.
Disclude version: 4.1.0
Scanned (UTC): 2026-10-22 13:44

Signals

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

info ~~warn~~ → info by review 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.70 A calculator tool in an OpenAI agents example evaluates a filtered arithmetic expression with eval.
Reasoning
eval is applied to an expression that is first checked for invalid characters and has ^ rewritten to **. The character filter limits the risk, but eval on model-supplied input is still an injection-prone pattern in example code. It looks like a calculator tool demo rather than deliberate malice.
info ~~warn~~ → info by review 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.70 A single-agent calculator example evaluates a filtered arithmetic expression with eval.
Reasoning
This is the same calculator tool as multi_agent.py, with the same character filter before eval. It is insecure eval use in an example, not evidence of hidden malicious behaviour.
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.95 Stack-walking helper in the PostHog exception utilities that reads frames via sys._getframe.
Reasoning
sys._getframe in a loop with a ValueError guard is the standard way to walk the call stack when building exception frames. It is a normal diagnostic pattern 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.
```
dismissed LLM, confidence 0.95 A base64url test fixture encoding a session token JSON object for an encode/decode compatibility test.
Reasoning
The blob is a short base64url-encoded JSON test fixture (session id, client name, version, timestamp) used to check wire-format compatibility. It is test data, 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))
```
dismissed LLM, confidence 0.95 A test decompresses a captured zlib request body to assert that the API key is not leaked.
Reasoning
zlib.decompress is applied to a captured mock request body in a unit test, and the test then checks that the API key is absent. This is ordinary test verification, not a runtime-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"))
```
dismissed LLM, confidence 0.95 A test helper gunzips and parses a mocked request body for assertions.
Reasoning
gzip.decompress is applied to a mocked HTTP request body in a test helper so the JSON can be inspected. This is standard test code.
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)
```
dismissed LLM, confidence 0.95 A request test gunzips the outgoing body and checks its contents.
Reasoning
The test decompresses a gzip request body and then asserts on the batch and api_key fields. This is normal verification of the client's 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
```
dismissed LLM, confidence 0.95 A tracing test helper decompresses and parses a captured gzip POST body.
Reasoning
A test helper gunzips a mock session.post body to parse the JSON for trace assertions. This is routine test code.
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):
```
dismissed LLM, confidence 0.95 A transport test decompresses the captured gzip body and compares it with the expected payload.
Reasoning
The test gunzips the captured request data and compares it to the expected PAYLOAD. This is ordinary transport verification in a test.

info long-line references/public_api_snapshot.txt:1279: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.1.0
git clone https://github.com/posthog/posthog-python posthog-python && cd posthog-python
git checkout posthog-v7.75.2
disclude scan --severity info --diff posthog-v7.75.1 .