posthog 7.73.2

Source: https://github.com/posthog/posthog-python
Tag scanned: posthog-v7.73.2
Compared with: posthog-v7.73.1 (0 signals introduced since)
Files: 430 scanned, 279 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 10 info
Scan time: 11.7 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 09:27

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 example agent evaluates a filtered math expression with eval.
Reasoning
The eval is preceded by a check that returns 'Error: invalid characters' for disallowed input, so the expression is filtered before evaluation. Eval of model-supplied text is still a risky pattern in an agent tool, but nothing here shows malicious intent or obfuscation.
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 example calculator tool evaluates a filtered math expression with eval.
Reasoning
This is the same calculator pattern as multi_agent.py, with the same character filter before eval. The risk is a poor coding practice in example code, not 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.92 Walks stack frames to collect context for exception reporting.
Reasoning
sys._getframe with a depth counter inside a try/except ValueError is the standard way to walk the stack for exception reporting. It is a legitimate SDK pattern.
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 base64 string in a test fixture encodes a benign session-token JSON payload.
Reasoning
The raw-pass base64 hit is a test fixture for a session token. It decodes to ordinary JSON with session, client and version fields, and the test compares it against a shared wire format. This is a high false-positive raw finding.
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.90 A test decompresses a captured zlib request body to verify its contents.
Reasoning
In a test, zlib.decompress round-trips a captured request body to check that the api_key is absent. This is ordinary test verification, not a runtime-hidden 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.90 A test helper gunzips and parses a captured request body.
Reasoning
In a test helper, gzip.decompress reads the request body so its JSON can be asserted. It is test plumbing with no sign of an embedded payload.
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.90 A test gunzips a request body to check its batch and api_key fields.
Reasoning
The test decompresses a gzip body to assert batch contents and the api key. This is routine verification of SDK output.
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.90 A test helper decompresses a mocked POST payload for inspection.
Reasoning
A test helper gunzips a mocked POST body to inspect the payload. This is standard test code with no evidence of concealed execution.
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.90 A transport test decompresses the request body to compare it with the expected payload.
Reasoning
The test gunzips the mocked request data and compares it with the expected PAYLOAD. It is an assertion on SDK output, not a dropper.

info long-line references/public_api_snapshot.txt:1212: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.73.2
disclude scan --severity info --diff posthog-v7.73.1 .