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: 10.1 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 9 of 9 warn and critical signals; 9 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-21 10:41

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 an arithmetic expression with eval after replacing '^' with '**'.
Reasoning
The eval runs on a string derived from model/user input, which is a real injection risk. The snippet shows a character check before it, though, and the code looks like an example calculator tool rather than hidden or malicious code. It is a weak pattern worth fixing, not evidence of intent.
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 calculator tool in an example agent evaluates an arithmetic expression with eval after replacing '^' with '**'.
Reasoning
This is the same calculator snippet as multi_agent.py, with the same character-validation guard before the eval. It is a weak eval pattern in example code, not obfuscation or 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 up the call stack with sys._getframe to collect frame information for exception reporting.
Reasoning
sys._getframe with a depth counter inside a try/except ValueError is a standard way to walk the stack for module or frame names in exception reporting. It is legitimate introspection, not a hidden execution path.
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.90 A base64-encoded session token fixture in an MCP test that decodes to a small JSON object.
Reasoning
The raw pass flags a base64-like string literal in a test fixture. It decodes to a small JSON object (session id, client name, version), and the comment indicates it matches a shared wire format. This is a test fixture, not a 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.90 A test decompresses a captured zlib request body to verify its contents.
Reasoning
zlib.decompress is applied to a request body captured from a mock in a test, then checked for the absence of api_key. This is a round-trip verification of the client's own compression, 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.90 A test helper decompresses a gzipped mock request body and parses it as JSON.
Reasoning
gzip.decompress is applied to a mocked request body in a test helper and parsed as JSON. This is ordinary test assertion 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.90 A test decompresses a captured gzip request body and asserts on its fields.
Reasoning
gzip.decompress is used on captured request data in a test to check the batch and api_key fields. This is standard test verification of the client's 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.90 A test helper decompresses a gzipped POST body from a mock session and parses the JSON.
Reasoning
gzip.decompress is applied to a mocked session.post payload in a test helper to check the sent JSON. It is ordinary 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.90 A transport test decompresses a gzipped request body and compares it with the expected payload.
Reasoning
gzip.decompress is used on a mocked request body in a transport test to compare against the expected payload. This is routine test verification.

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.0.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 .