posthog 7.75.1

Source: https://github.com/posthog/posthog-python
Tag scanned: posthog-v7.75.1
Compared with: posthog-v7.75.0 (0 signals introduced since)
Files: 441 scanned, 283 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 2 warn · 8 info
Scan time: 10.6 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 9 of 9 warn and critical signals; 7 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+…⟩.

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 OpenAI Agents example evaluates a character-filtered expression with eval.
Reasoning
eval is applied to an expression that has been filtered for invalid characters just above, and the code is example calculator-tool code. Still, eval on model-supplied input is a known code-injection hazard, and the character filter is not a sandbox, so this is a poor pattern rather than evidence of malicious intent.
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 calculator example evaluates a character-filtered expression with eval.
Reasoning
This is the same calculator-tool eval pattern as the multi-agent example, with the same character pre-filter. It is an insecure example pattern, not an obfuscated or malicious payload.
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 Exception-reporting utility walks stack frames via sys._getframe to gather context.
Reasoning
Walking the call stack with sys._getframe(depth) in a loop that catches ValueError is the standard way exception-reporting libraries collect frame information. The context is legitimate.
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 Test fixture containing a base64url-encoded JSON session token.
Reasoning
The blob is a short base64url JSON fixture (session id, client name, version, timestamp) used as a shared wire-format test vector in a test file. It is not hidden or executed.
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.92 Test round-trips and inspects a zlib-compressed request body.
Reasoning
The test decompresses a zlib payload it just generated, checks the zlib header, and asserts that the API key is absent from the round-tripped JSON. This is a normal test assertion, not a runtime-dropped 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.92 Test helper decompresses a gzip request body captured from a mock.
Reasoning
The helper gunzips the mocked HTTP request body to inspect the JSON that was sent. This is test-side verification of the client's own output.
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.92 Test decompresses a gzip request body to check its contents.
Reasoning
The test gunzips the request body and checks the batch and API key fields. This is ordinary assertion code on the library's own 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.92 Test helper decompresses a gzip POST body from a mock session.
Reasoning
The helper gunzips the mocked session.post data so the test can compare the JSON payload. This is standard test plumbing.
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.92 Transport test decompresses a gzip body and compares it with the expected payload.
Reasoning
The assertion gunzips the outgoing request body and compares it to the expected PAYLOAD. This is a test checking transport output.

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.1
disclude scan --severity info --diff posthog-v7.75.0 .