posthog 7.75.11

Source: https://github.com/posthog/posthog-python
Artifact scanned: posthog-7.75.11-py3-none-any.whl (wheel · 935.6 KB · SHA-256 c65d173b24ec…)
Compared with: posthog-7.75.10-py3-none-any.whl (0 signals introduced since)
Files: 265 scanned, 5 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 7 info
Scan time: 5.8 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 7 of 7 warn and critical signals; 7 demoted to info.
Disclude version: 4.3.0
Scanned (UTC): 2026-10-23 16:42

Signals

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

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.85 Walks call-stack frames via sys._getframe to build exception context for PostHog error tracking.
Reasoning
sys._getframe(depth) in a loop walking up the stack with ValueError handling is a standard way to collect frames for exception stack traces in an SDK; no execution or exfiltration of decoded data.
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.93 Test fixture containing a base64-encoded session token in a unit test.
Reasoning
A base64url-encoded JSON string literal used as a test fixture for a session token wire format; the decoded content is plain metadata (session id, client name, version) and the test comments indicate byte-compatibility checks.
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.93 Test decompresses a captured zlib request body to assert on its JSON contents.
Reasoning
zlib.decompress is applied to captured request data in a test to verify the payload does not leak api_key; this is verification of outgoing data, not runtime execution of an 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"))
```
likely benign LLM, confidence 0.94 Test helper gunzips a mocked HTTP body and parses the JSON for assertions.
Reasoning
gzip.decompress on a mocked request body inside a test helper to parse JSON for assertions; standard test plumbing with no execution of decoded content.
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.94 Test gunzips and parses a captured request body to check its contents.
Reasoning
gzip.decompress of captured request data followed by JSON parsing and assertions on batch and api_key fields; ordinary test 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
```
likely benign LLM, confidence 0.94 Test helper decompresses and parses a mocked POST body for trace assertions.
Reasoning
gzip.decompress of mocked session.post data passed to json.loads inside a test helper; benign verification of serialized payloads.
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.94 Test checks that the gzip-compressed transport body decodes to the expected payload.
Reasoning
gzip.decompress of captured request kwargs compared against an expected PAYLOAD in a unit test; no runtime execution of embedded content.

Reproduce This Scan

Run disclude locally to verify. These commands scan the published file; the "new in this release" marks come from comparing it with the previous release's file, which they don't repeat. 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.3.0
curl -fsSL -o posthog-7.75.11-py3-none-any.whl https://files.pythonhosted.org/packages/50/8c/7765ea5122fe96daf9d3db4653fc37f2ca5115e2f6f7f4d74f0867433a8a/posthog-7.75.11-py3-none-any.whl
printf '%s  %s\n' c65d173b24ec82cbf0f977f4779348512a7f71b761809786e87ae47e347ebab1 posthog-7.75.11-py3-none-any.whl | shasum -a 256 -c -
unzip -q posthog-7.75.11-py3-none-any.whl -d pkg
disclude scan --untrusted --severity info pkg