[peterolkhov]

💡 Motivation and Context

A NaN exception rate-limit setting passes the current range checks. A NaN refill interval then drops every autocaptured exception after the first with ValueError: cannot convert float NaN to integer; a NaN bucket size never becomes rate limited.

Treat NaN like the existing invalid-number inputs and use the logged maximum fallback. This matches the JS limiter’s NaN handling. Existing zero, boolean/type fallback, huge-integer, and infinity behavior stays covered.

💚 How did you test it?

• Five new NaN regressions fail before the fix. All 51 focused limiter/exception-capture tests pass afterward, including the public client’s installed exception hook.
• A standalone local smoke test uses the real client, installed exception hook, serialization and HTTP transport against a disposable localhost receiver: it receives the expected two of six exceptions for a NaN interval and 99 of 105 for a NaN bucket. No live PostHog ingestion or manual UI testing is claimed.
• Ruff formatting/lint, mypy, strict import, public API checks, downstream strict typing, package build and Twine checks pass.
• Full pytest --verbose --timeout=30: 6207 passed, 26 skipped, 3 failed. The three failures are existing macOS metrics-fork cases: test_keeps_working_in_a_forked_child, test_exports_from_a_child_forked_during_an_export, and test_records_in_a_child_forked_during_a_collection. All three also fail on an unchanged archive of base SHA ac55b350a0f8391593de5f2e2b2fa0d6eebc80dc in the same environment; imported package paths were printed to verify the baseline. Child processes abort in macOS system-proxy handling after fork. No unrelated code was changed.

📝 Checklist

• All commits are signed.
• I reviewed the submitted code.
• I added tests to verify the changes.
• I updated the docs if needed.
• No breaking change or entry added to the changelog.

If releasing new changes

• Ran sampo add to generate a changeset file.

🤖 Agent context

Autonomy: Human-driven (agent-assisted).

Peter directed this contribution. A Codex GPT-6.1 Sol worker with high reasoning investigated and implemented it using Git/GitHub CLI, uv, pytest, Ruff, mypy and Sampo. The diagnosis traced the installed exception hook through the shared limiter to missing upload attempts, then compared the original JS normalization. The fix preserves existing clamping semantics instead of adding a new configuration error or changing infinity handling.

No human code review has occurred yet; the review checkbox is intentionally unchecked. Human review is required before merge. No public agent-session link is available; the behavior, verification commands and limits are described above.

DRI: @peterolkhov. GitHub denied the attempt to set the assignee with this account’s repository permissions; a maintainer will need to set that assignment.

[marandaneto]

The code looks good; no qualifying findings. Verdict: correct.

[github-actions]

SDK performance: posthog-python

Benchmarks completed. No changes flagged for review.

Flags require at least a 5% change in the median and all six pairs agreeing on direction. This is a noise filter, not proof of a performance change or a CI gate.

View all results

Test	Measurement	Before PR	With PR	Change	Assessment
Capture and deliver events (32-byte payload, burst) Shard: capture	Managed heap after settling	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Managed heap after settling	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (32-byte payload, steady) Shard: capture	Managed heap after settling	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Managed heap after settling	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Queue an event (32-byte payload) Shard: capture	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Queue an event (32-byte payload) Shard: capture	Allocations per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Queue an event (4,096-byte payload) Shard: capture	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Queue an event (4,096-byte payload) Shard: capture	Allocations per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​; head:​ Background preparation has no public completion boundary before flush; see capture.​drain for full-pipeline allocations.​
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Managed heap after settling	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Refresh 1,000 flag definitions Shard: flags-memory	Managed heap after settling	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​; head:​ CPython has no uninstrumented total managed-heap byte counter; tracing would distort this RSS pass.​
Capture and deliver events (32-byte payload, burst) Shard: capture	Allocated memory per operation	113.54 KiB/op	113.54 KiB/op	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Allocations per operation	1,096.61 count/op	1,096.6 count/op	<0.1% fewer	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Time per operation	68.73 µs/op	70.72 µs/op	2.9% more time	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Idle process memory (RSS)	36 MiB	36.03 MiB	<0.1% more memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Observed peak process memory (RSS)	37.74 MiB	37.77 MiB	<0.1% more memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Process memory after settling (RSS)	37.74 MiB	37.77 MiB	<0.1% more memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Process CPU time per operation	69.26 µs/op	71.7 µs/op	3.5% more time	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Lifetime peak process memory (RSS)	40.2 MiB	40.2 MiB	No observed change	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Allocated memory per operation	166.1 KiB/op	166.1 KiB/op	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Allocations per operation	1,089.59 count/op	1,089.58 count/op	<0.1% fewer	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Time per operation	96.83 µs/op	96.59 µs/op	0.2% less time	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Idle process memory (RSS)	40.88 MiB	40.75 MiB	0.3% less memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Observed peak process memory (RSS)	45.96 MiB	45.84 MiB	0.3% less memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Process memory after settling (RSS)	45.96 MiB	45.84 MiB	0.3% less memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Process CPU time per operation	90.32 µs/op	89.75 µs/op	0.6% less time	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Lifetime peak process memory (RSS)	50.8 MiB	50.71 MiB	0.2% less memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Allocated memory per operation	117.68 KiB/op	117.68 KiB/op	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Allocations per operation	1,136.59 count/op	1,136.56 count/op	<0.1% fewer	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Time per operation	84.06 µs/op	81.95 µs/op	2.5% less time	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Idle process memory (RSS)	35.94 MiB	35.94 MiB	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Observed peak process memory (RSS)	36.05 MiB	36.05 MiB	No observed change	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Process memory after settling (RSS)	36.05 MiB	36.05 MiB	No observed change	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Process CPU time per operation	82.1 µs/op	79.61 µs/op	3% less time	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Lifetime peak process memory (RSS)	40.2 MiB	40.2 MiB	No observed change	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Allocated memory per operation	170.57 KiB/op	170.57 KiB/op	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Allocations per operation	1,129.51 count/op	1,129.49 count/op	<0.1% fewer	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Time per operation	107.33 µs/op	107.41 µs/op	<0.1% more time	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Idle process memory (RSS)	40.66 MiB	40.65 MiB	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Observed peak process memory (RSS)	40.66 MiB	40.66 MiB	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Process memory after settling (RSS)	40.66 MiB	40.66 MiB	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Process CPU time per operation	102.79 µs/op	102.85 µs/op	<0.1% more time	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Lifetime peak process memory (RSS)	40.92 MiB	40.94 MiB	<0.1% more memory	Not flagged
Queue an event (32-byte payload) Shard: capture	Caller-thread CPU time per operation	47.97 µs/op	46.54 µs/op	3% less time	Not flagged
Queue an event (32-byte payload) Shard: capture	Time per operation	48.86 µs/op	47.27 µs/op	3.3% less time	Not flagged
Queue an event (4,096-byte payload) Shard: capture	Caller-thread CPU time per operation	49.48 µs/op	46.34 µs/op	6.4% less time	Not flagged
Queue an event (4,096-byte payload) Shard: capture	Time per operation	51.27 µs/op	46.34 µs/op	9.6% less time	Not flagged
Evaluate all 10 flags Shard: flags-scaling	Allocated memory per operation	200.98 KiB/op	200.98 KiB/op	No observed change	Not flagged
Evaluate all 10 flags Shard: flags-scaling	Allocations per operation	2,339.33 count/op	2,339.33 count/op	No observed change	Not flagged
Evaluate all 10 flags Shard: flags-scaling	Time per operation	87.8 µs/op	87.95 µs/op	0.2% more time	Not flagged
Evaluate all 10 flags Shard: flags-scaling	Process CPU time per operation	87.79 µs/op	87.95 µs/op	0.2% more time	Not flagged
Evaluate all 100 flags Shard: flags-scaling	Allocated memory per operation	1.93 MiB/op	1.93 MiB/op	No observed change	Not flagged
Evaluate all 100 flags Shard: flags-scaling	Allocations per operation	23,013.56 count/op	23,013.56 count/op	No observed change	Not flagged
Evaluate all 100 flags Shard: flags-scaling	Time per operation	854.33 µs/op	858.59 µs/op	0.5% more time	Not flagged
Evaluate all 100 flags Shard: flags-scaling	Process CPU time per operation	854.28 µs/op	858.61 µs/op	0.5% more time	Not flagged
Evaluate all 1,000 flags Shard: flags-scaling	Allocated memory per operation	19.24 MiB/op	19.24 MiB/op	No observed change	Not flagged
Evaluate all 1,000 flags Shard: flags-scaling	Allocations per operation	229,654.94 count/op	229,654.94 count/op	No observed change	Not flagged
Evaluate all 1,000 flags Shard: flags-scaling	Time per operation	8.61 ms/op	8.59 ms/op	0.2% less time	Not flagged
Evaluate all 1,000 flags Shard: flags-scaling	Process CPU time per operation	8.61 ms/op	8.59 ms/op	0.2% less time	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Idle process memory (RSS)	42.35 MiB	42.07 MiB	0.7% less memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Observed peak process memory (RSS)	42.69 MiB	42.36 MiB	0.8% less memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Process memory after settling (RSS)	42.69 MiB	42.36 MiB	0.8% less memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Lifetime peak process memory (RSS)	42.51 MiB	42.39 MiB	0.3% less memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Idle process memory (RSS)	41.28 MiB	42.08 MiB	1.9% more memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Observed peak process memory (RSS)	42.01 MiB	42.17 MiB	0.4% more memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Process memory after settling (RSS)	41.55 MiB	42.17 MiB	1.5% more memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Lifetime peak process memory (RSS)	42.52 MiB	42.55 MiB	<0.1% more memory	Not flagged
Evaluate one boolean flag Shard: flags-single	Allocated memory per operation	15.05 KiB/op	15.05 KiB/op	No observed change	Not flagged
Evaluate one boolean flag Shard: flags-single	Allocations per operation	173.76 count/op	173.76 count/op	No observed change	Not flagged
Evaluate one boolean flag Shard: flags-single	Time per operation	13.73 µs/op	13.88 µs/op	1% more time	Not flagged
Evaluate one boolean flag Shard: flags-single	Process CPU time per operation	13.73 µs/op	13.88 µs/op	1.1% more time	Not flagged
Evaluate a cohort-filtered flag Shard: flags-single	Allocated memory per operation	23.12 KiB/op	23.12 KiB/op	No observed change	Not flagged
Evaluate a cohort-filtered flag Shard: flags-single	Allocations per operation	270.27 count/op	270.27 count/op	No observed change	Not flagged
Evaluate a cohort-filtered flag Shard: flags-single	Time per operation	21.55 µs/op	21.62 µs/op	0.3% more time	Not flagged
Evaluate a cohort-filtered flag Shard: flags-single	Process CPU time per operation	21.55 µs/op	21.62 µs/op	0.3% more time	Not flagged
Evaluate a flag (early match) Shard: flags-single	Allocated memory per operation	35.71 KiB/op	35.71 KiB/op	No observed change	Not flagged
Evaluate a flag (early match) Shard: flags-single	Allocations per operation	387.27 count/op	387.27 count/op	No observed change	Not flagged
Evaluate a flag (early match) Shard: flags-single	Time per operation	27.44 µs/op	27.32 µs/op	0.5% less time	Not flagged
Evaluate a flag (early match) Shard: flags-single	Process CPU time per operation	27.44 µs/op	27.31 µs/op	0.5% less time	Not flagged
Evaluate a flag (late match) Shard: flags-single	Allocated memory per operation	53.59 KiB/op	53.59 KiB/op	No observed change	Not flagged
Evaluate a flag (late match) Shard: flags-single	Allocations per operation	576.27 count/op	576.27 count/op	No observed change	Not flagged
Evaluate a flag (late match) Shard: flags-single	Time per operation	38.44 µs/op	37.93 µs/op	1.3% less time	Not flagged
Evaluate a flag (late match) Shard: flags-single	Process CPU time per operation	38.44 µs/op	37.93 µs/op	1.3% less time	Not flagged
Evaluate a flag (no match) Shard: flags-single	Allocated memory per operation	52.14 KiB/op	52.14 KiB/op	No observed change	Not flagged
Evaluate a flag (no match) Shard: flags-single	Allocations per operation	556.77 count/op	556.77 count/op	No observed change	Not flagged
Evaluate a flag (no match) Shard: flags-single	Time per operation	34.61 µs/op	34.67 µs/op	0.2% more time	Not flagged
Evaluate a flag (no match) Shard: flags-single	Process CPU time per operation	34.6 µs/op	34.67 µs/op	0.2% more time	Not flagged
Evaluate a property-filtered flag Shard: flags-single	Allocated memory per operation	17.84 KiB/op	17.84 KiB/op	No observed change	Not flagged
Evaluate a property-filtered flag Shard: flags-single	Allocations per operation	198.27 count/op	198.27 count/op	No observed change	Not flagged
Evaluate a property-filtered flag Shard: flags-single	Time per operation	16.5 µs/op	16.26 µs/op	1.5% less time	Not flagged
Evaluate a property-filtered flag Shard: flags-single	Process CPU time per operation	16.5 µs/op	16.25 µs/op	1.5% less time	Not flagged
Evaluate a regex-filtered flag Shard: flags-single	Allocated memory per operation	19.23 KiB/op	19.23 KiB/op	No observed change	Not flagged
Evaluate a regex-filtered flag Shard: flags-single	Allocations per operation	210.77 count/op	210.77 count/op	No observed change	Not flagged
Evaluate a regex-filtered flag Shard: flags-single	Time per operation	17.29 µs/op	17.23 µs/op	0.3% less time	Not flagged
Evaluate a regex-filtered flag Shard: flags-single	Process CPU time per operation	17.29 µs/op	17.23 µs/op	0.3% less time	Not flagged
Evaluate a rollout flag Shard: flags-single	Allocated memory per operation	14.04 KiB/op	14.04 KiB/op	No observed change	Not flagged
Evaluate a rollout flag Shard: flags-single	Allocations per operation	160.76 count/op	160.76 count/op	No observed change	Not flagged
Evaluate a rollout flag Shard: flags-single	Time per operation	12.97 µs/op	12.97 µs/op	<0.1% more time	Not flagged
Evaluate a rollout flag Shard: flags-single	Process CPU time per operation	12.97 µs/op	12.97 µs/op	<0.1% more time	Not flagged
Evaluate a multivariate flag Shard: flags-single	Allocated memory per operation	15.21 KiB/op	15.21 KiB/op	No observed change	Not flagged
Evaluate a multivariate flag Shard: flags-single	Allocations per operation	177.77 count/op	177.77 count/op	No observed change	Not flagged
Evaluate a multivariate flag Shard: flags-single	Time per operation	14.52 µs/op	14.54 µs/op	0.1% more time	Not flagged
Evaluate a multivariate flag Shard: flags-single	Process CPU time per operation	14.52 µs/op	14.54 µs/op	0.1% more time	Not flagged

Values are medians of paired measurements. Not flagged does not mean unchanged. Unavailable means a measurement could not be provided, not zero. Estimated allocation measurements retain their instrumentation uncertainty. RSS measures the whole process, not just SDK allocations; observed peaks are sampled checkpoints. Paired ranges in the diagnostics describe variability, not confidence intervals.

Each shard uses its own runner; compare Before PR against With PR within a row, not across shards.

Compared ac55b350a0f8391593de5f2e2b2fa0d6eebc80dc → c601427b52390b8c3d3236515f4cd08a298cd592.

Full report and diagnostics

102 metric rows; 102 rows shown in all results. Omitted or shortened data remain in comparison.json, including per-runner environments, resource limits, measurement methods, samples and checkpoints.