[marandaneto]

💡 Motivation and Context

Rails template methods include numeric hash and object ID suffixes that can change between processes. Those numbers make exception frame function names unstable.

This removes only those suffixes when Rails is loaded and the generated identifier matches the frame's absolute source path or Action View's short identifier. Matching uses Rails' actual root semantics, including stripping the leading slash when Rails.root is nil. Readable template names and block prefixes remain. Ordinary methods, filenames, line numbers, source context, frame classification, cause chains, and duplicate capture prevention stay unchanged. No frames are hidden or removed, and there is no new public API or configuration.

The existing patch changeset includes both runtime packages because the parser lives in posthog-ruby. The capture-exception and exception-event-metadata specs were checked. No divergence was identified for the touched behavior. Template method normalization itself is not specified there. The branch includes a signed merge of main at 81093eaf8199fee1330758bb9940a4d17b2acfdc.

💚 How did you test it?

• The template backtrace suite has 32 examples covering numeric suffix signs, both Ruby quote styles, block prefixes, encoded punctuation and digits, nil Rails root, absent Rails, mismatched source paths, and dependency classification.
• Replaced the synthetic nil-root example with a real Action View-generated method. A real failing rendered template is also captured with and without an application root. Both cases check wrapper and cause frames, source context, frame counts, original backtraces, and duplicate capture prevention.
• Before the nil-root fix, bundle exec rspec spec/posthog/rails/template_backtrace_spec.rb ran 32 examples with 2 failures: generated and rendered template names retained their numeric suffixes. The same command passed all 32 examples after the fix. The template and neighboring parser specs passed 56 examples.
• Final merged HEAD on Ruby 4.0.7 and Rails 7.2.3.1: full base suite passed 2201 examples with 40 pending. Full optional OpenTelemetry suite passed 2201 examples with 2 pending.
• A separate external Gemfile referencing this worktree resolved Rails 8.1.4 and eligible latest dependencies. Its full OpenTelemetry suite passed 2201 examples with no pending tests. Committed lockfiles were not changed by that resolution.
• RuboCop passed for all 151 files. bundle exec rake public_api:check and git diff --check origin/main...HEAD passed.
• Completed the test-audit Authoring gate and diff-scoped deslop review. Exact-HEAD isolated autoreview for 39404bc02f0cdb9b42f0354e48c4c3d8cac0629c against origin/main reported no findings.
• Historical Ruby/Rails combinations were not run locally. Hosted Unit Tests run 42346704707 passed all 9 jobs for the pushed SHA, including Ruby 3.2, 3.3 and 3.4, optional integration suites, and latest Rails on stable Ruby.

📝 Checklist

• All commits are signed (see Commit signing)
• 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 pnpm changeset to generate a changeset file

A hand-authored patch changeset is included. No duplicate changeset or version bump was generated.

🤖 Agent context

Autonomy: Human-driven (agent-assisted)

Human DRI: @marandaneto. Pi's worker implementation subagent used local file tools, Bash, Git, GitHub CLI, and the autoreview helper with claude-code/claude-opus-5-5. There is no public session link.

The change stays within private parser normalization and preserves existing stack data. Review feedback was reproduced using real Action View identifiers before fixing root matching. Agent-assisted review and validation do not replace human review.

[github-actions]

posthog-ruby-sync Compliance Report

Date: 2026-11-07T06:23:42.545097+00:00
Duration: 55869ms

⚠️ Some Tests Failed

39/47 tests passed, 8 failed

---

Capture Tests

⚠️ 23/30 tests passed, 7 failed

View Details

Test	Status	Duration
Format Validation.Event Has Required Fields	✅	10ms
Format Validation.Event Has Uuid	✅	7ms
Format Validation.Event Has Lib Properties	✅	7ms
Format Validation.Distinct Id Is String	✅	9ms
Format Validation.Token Is Present	✅	7ms
Format Validation.Custom Properties Preserved	✅	9ms
Format Validation.Event Has Timestamp	✅	9ms
Format Validation.Non Utc Event Timestamp Is Converted To Utc	✅	7ms
Retry Behavior.Retries On 503	✅	5248ms
Retry Behavior.Does Not Retry On 400	❌	7ms
Retry Behavior.Does Not Retry On 401	❌	5ms
Retry Behavior.Respects Retry After Header	✅	8015ms
Retry Behavior.Implements Backoff	❌	235ms
Retry Behavior.Retries On 500	✅	5115ms
Retry Behavior.Retries On 502	✅	5151ms
Retry Behavior.Retries On 504	✅	5158ms
Retry Behavior.Max Retries Respected	❌	473ms
Deduplication.Generates Unique Uuids	✅	19ms
Deduplication.Preserves Uuid On Retry	✅	5113ms
Deduplication.Preserves Uuid And Timestamp On Retry	✅	10259ms
Deduplication.Preserves Uuid And Timestamp On Batch Retry	✅	5120ms
Deduplication.No Duplicate Events In Batch	✅	20ms
Deduplication.Different Events Have Different Uuids	✅	10ms
Compression.Sends Gzip When Enabled	✅	7ms
Batch Format.Uses Proper Batch Structure	✅	6ms
Batch Format.Flush With No Events Sends Nothing	✅	4ms
Batch Format.Multiple Events Batched Together	❌	17ms
Error Handling.Does Not Retry On 403	❌	5ms
Error Handling.Does Not Retry On 413	❌	5ms
Error Handling.Retries On 408	✅	5151ms

Failures

retry_behavior.does_not_retry_on_400

500, message='Internal Server Error', url='http://sdk-adapter:8080/capture'

retry_behavior.does_not_retry_on_401

500, message='Internal Server Error', url='http://sdk-adapter:8080/capture'

retry_behavior.implements_backoff

500, message='Internal Server Error', url='http://sdk-adapter:8080/capture'

retry_behavior.max_retries_respected

500, message='Internal Server Error', url='http://sdk-adapter:8080/capture'

batch_format.multiple_events_batched_together

Expected 1 requests, got 5

error_handling.does_not_retry_on_403

500, message='Internal Server Error', url='http://sdk-adapter:8080/capture'

error_handling.does_not_retry_on_413

500, message='Internal Server Error', url='http://sdk-adapter:8080/capture'

Feature_Flags Tests

⚠️ 16/17 tests passed, 1 failed

View Details

Test	Status	Duration
Request Payload.Request With Person Properties Device Id	✅	11ms
Request Payload.Flags Request Uses V2 Query Param	✅	10ms
Request Payload.Flags Request Hits Flags Path Not Decide	✅	10ms
Request Payload.Flags Request Omits Authorization Header	✅	9ms
Request Payload.Token In Flags Body Matches Init	✅	7ms
Request Payload.Groups Round Trip	✅	7ms
Request Payload.Groups Default To Empty Object	✅	7ms
Request Payload.Disable Geoip False Propagates As Geoip Disable False	✅	7ms
Request Payload.Disable Geoip Omitted Defaults To False	❌	6ms
Request Payload.Flag Keys To Evaluate Contains Only Requested Key	✅	8ms
Request Lifecycle.No Flags Request On Init Alone	✅	2ms
Request Lifecycle.No Flags Request On Normal Capture	✅	7ms
Request Lifecycle.Two Flag Calls Produce Two Remote Requests	✅	10ms
Request Lifecycle.Mock Response Value Is Returned To Caller	✅	8ms
Retry Behavior.Retries Flags On 502	✅	110ms
Retry Behavior.Retries Flags On 504	✅	110ms
Side Effect Events.Get Feature Flag Captures Feature Flag Called Event	✅	10ms

Failures

request_payload.disable_geoip_omitted_defaults_to_false

Field 'geoip_disable' not found in /flags request body at path 'geoip_disable'. Available keys: ['distinct_id', 'groups', 'person_properties', 'group_properties', 'flag_keys_to_evaluate', 'token']

[github-actions]

posthog-ruby-async Compliance Report

Date: 2026-11-07T06:24:22.090348+00:00
Duration: 98270ms

⚠️ Some Tests Failed

46/47 tests passed, 1 failed

---

Capture Tests

✅ 30/30 tests passed

View Details

Test	Status	Duration
Format Validation.Event Has Required Fields	✅	107ms
Format Validation.Event Has Uuid	✅	104ms
Format Validation.Event Has Lib Properties	✅	106ms
Format Validation.Distinct Id Is String	✅	104ms
Format Validation.Token Is Present	✅	105ms
Format Validation.Custom Properties Preserved	✅	106ms
Format Validation.Event Has Timestamp	✅	105ms
Format Validation.Non Utc Event Timestamp Is Converted To Utc	✅	106ms
Retry Behavior.Retries On 503	✅	5311ms
Retry Behavior.Does Not Retry On 400	✅	2106ms
Retry Behavior.Does Not Retry On 401	✅	2107ms
Retry Behavior.Respects Retry After Header	✅	8113ms
Retry Behavior.Implements Backoff	✅	15618ms
Retry Behavior.Retries On 500	✅	5209ms
Retry Behavior.Retries On 502	✅	5210ms
Retry Behavior.Retries On 504	✅	5210ms
Retry Behavior.Max Retries Respected	✅	15609ms
Deduplication.Generates Unique Uuids	✅	108ms
Deduplication.Preserves Uuid On Retry	✅	5210ms
Deduplication.Preserves Uuid And Timestamp On Retry	✅	10316ms
Deduplication.Preserves Uuid And Timestamp On Batch Retry	✅	5212ms
Deduplication.No Duplicate Events In Batch	✅	108ms
Deduplication.Different Events Have Different Uuids	✅	105ms
Compression.Sends Gzip When Enabled	✅	104ms
Batch Format.Uses Proper Batch Structure	✅	106ms
Batch Format.Flush With No Events Sends Nothing	✅	5ms
Batch Format.Multiple Events Batched Together	✅	108ms
Error Handling.Does Not Retry On 403	✅	2107ms
Error Handling.Does Not Retry On 413	✅	2107ms
Error Handling.Retries On 408	✅	5210ms

Feature_Flags Tests

⚠️ 16/17 tests passed, 1 failed

View Details

Test	Status	Duration
Request Payload.Request With Person Properties Device Id	✅	106ms
Request Payload.Flags Request Uses V2 Query Param	✅	106ms
Request Payload.Flags Request Hits Flags Path Not Decide	✅	105ms
Request Payload.Flags Request Omits Authorization Header	✅	105ms
Request Payload.Token In Flags Body Matches Init	✅	105ms
Request Payload.Groups Round Trip	✅	106ms
Request Payload.Groups Default To Empty Object	✅	105ms
Request Payload.Disable Geoip False Propagates As Geoip Disable False	✅	106ms
Request Payload.Disable Geoip Omitted Defaults To False	❌	106ms
Request Payload.Flag Keys To Evaluate Contains Only Requested Key	✅	113ms
Request Lifecycle.No Flags Request On Init Alone	✅	2ms
Request Lifecycle.No Flags Request On Normal Capture	✅	105ms
Request Lifecycle.Two Flag Calls Produce Two Remote Requests	✅	110ms
Request Lifecycle.Mock Response Value Is Returned To Caller	✅	105ms
Retry Behavior.Retries Flags On 502	✅	237ms
Retry Behavior.Retries Flags On 504	✅	240ms
Side Effect Events.Get Feature Flag Captures Feature Flag Called Event	✅	107ms

Failures

request_payload.disable_geoip_omitted_defaults_to_false

Field 'geoip_disable' not found in /flags request body at path 'geoip_disable'. Available keys: ['distinct_id', 'groups', 'person_properties', 'group_properties', 'flag_keys_to_evaluate', 'token']

[github-actions]

SDK performance: posthog-ruby

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	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Capture and deliver events (32-byte payload, steady) Shard: capture	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Queue an event (32-byte payload) Shard: capture	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Background serialization has no public enqueue completion boundary; use completed-delivery workloads for process-wide allocation counts.​; head:​ Background serialization has no public enqueue completion boundary; use completed-delivery workloads for process-wide allocation counts.​
Queue an event (32-byte payload) Shard: capture	Allocations per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Background serialization has no public enqueue completion boundary; use completed-delivery workloads for process-wide allocation counts.​; head:​ Background serialization has no public enqueue completion boundary; use completed-delivery workloads for process-wide allocation counts.​
Queue an event (4,096-byte payload) Shard: capture	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Background serialization has no public enqueue completion boundary; use completed-delivery workloads for process-wide allocation counts.​; head:​ Background serialization has no public enqueue completion boundary; use completed-delivery workloads for process-wide allocation counts.​
Queue an event (4,096-byte payload) Shard: capture	Allocations per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Background serialization has no public enqueue completion boundary; use completed-delivery workloads for process-wide allocation counts.​; head:​ Background serialization has no public enqueue completion boundary; use completed-delivery workloads for process-wide allocation counts.​
Evaluate all 10 flags Shard: flags-scaling	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate all 100 flags Shard: flags-scaling	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate all 1,000 flags Shard: flags-scaling	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate one boolean flag Shard: flags-single	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate a cohort-filtered flag Shard: flags-single	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate a flag (early match) Shard: flags-single	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate a flag (late match) Shard: flags-single	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate a flag (no match) Shard: flags-single	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate a property-filtered flag Shard: flags-single	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate a regex-filtered flag Shard: flags-single	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate a rollout flag Shard: flags-single	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Evaluate a multivariate flag Shard: flags-single	Allocated memory per operation	—	—	—	unavailable; base:​ unsupported; head:​ unsupported; base:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​; head:​ Ruby has no cumulative allocated-byte counter here; retained ObjectSpace bytes are not allocation volume.​
Capture and deliver events (32-byte payload, burst) Shard: capture	Allocations per operation	56.27 count/op	56.27 count/op	No observed change	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Time per operation	111.74 µs/op	111.77 µs/op	<0.1% more time	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Idle process memory (RSS)	28.41 MiB	28.39 MiB	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Observed peak process memory (RSS)	31.17 MiB	31.14 MiB	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Managed heap after settling	5.27 MiB	5.28 MiB	<0.1% more memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Process memory after settling (RSS)	30.4 MiB	30.38 MiB	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Process CPU time per operation	26.88 µs/op	26.84 µs/op	0.2% less time	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Lifetime peak process memory (RSS)	30.94 MiB	30.92 MiB	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Allocations per operation	58.65 count/op	58.65 count/op	No observed change	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Time per operation	111.91 µs/op	111.94 µs/op	<0.1% more time	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Idle process memory (RSS)	33.16 MiB	33.14 MiB	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Observed peak process memory (RSS)	42.37 MiB	42.35 MiB	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Managed heap after settling	9.14 MiB	9.14 MiB	<0.1% more memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Process memory after settling (RSS)	40.65 MiB	40.63 MiB	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Process CPU time per operation	39.58 µs/op	40.42 µs/op	2.1% more time	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Lifetime peak process memory (RSS)	42.26 MiB	42.14 MiB	0.3% less memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Allocations per operation	58.68 count/op	58.68 count/op	No observed change	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Time per operation	1.02 ms/op	1.02 ms/op	<0.1% more time	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Idle process memory (RSS)	28.31 MiB	28.31 MiB	<0.1% more memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Observed peak process memory (RSS)	30.4 MiB	30.38 MiB	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Managed heap after settling	5.27 MiB	5.28 MiB	<0.1% more memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Process memory after settling (RSS)	30.4 MiB	30.38 MiB	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Process CPU time per operation	43.09 µs/op	42.92 µs/op	0.4% less time	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Lifetime peak process memory (RSS)	30.4 MiB	30.38 MiB	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Allocations per operation	58.68 count/op	58.68 count/op	No observed change	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Time per operation	1.02 ms/op	1.02 ms/op	<0.1% more time	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Idle process memory (RSS)	33.15 MiB	33.17 MiB	<0.1% more memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Observed peak process memory (RSS)	40.47 MiB	40.54 MiB	0.2% more memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Managed heap after settling	9.14 MiB	9.14 MiB	<0.1% more memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Process memory after settling (RSS)	40.13 MiB	40.27 MiB	0.3% more memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Process CPU time per operation	50.47 µs/op	51.22 µs/op	1.5% more time	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Lifetime peak process memory (RSS)	40.82 MiB	40.79 MiB	<0.1% less memory	Not flagged
Queue an event (32-byte payload) Shard: capture	Caller-thread CPU time per operation	11.57 µs/op	11.49 µs/op	0.7% less time	Not flagged
Queue an event (32-byte payload) Shard: capture	Time per operation	11.57 µs/op	11.48 µs/op	0.7% less time	Not flagged
Queue an event (4,096-byte payload) Shard: capture	Caller-thread CPU time per operation	11.51 µs/op	11.42 µs/op	0.7% less time	Not flagged
Queue an event (4,096-byte payload) Shard: capture	Time per operation	11.51 µs/op	11.42 µs/op	0.8% less time	Not flagged
Evaluate all 10 flags Shard: flags-scaling	Allocations per operation	343.02 count/op	343.02 count/op	No observed change	Not flagged
Evaluate all 10 flags Shard: flags-scaling	Time per operation	153.72 µs/op	152.66 µs/op	0.7% less time	Not flagged
Evaluate all 10 flags Shard: flags-scaling	Process CPU time per operation	153.73 µs/op	152.66 µs/op	0.7% less time	Not flagged
Evaluate all 100 flags Shard: flags-scaling	Allocations per operation	3,324 count/op	3,324 count/op	No observed change	Not flagged
Evaluate all 100 flags Shard: flags-scaling	Time per operation	1.45 ms/op	1.46 ms/op	0.9% more time	Not flagged
Evaluate all 100 flags Shard: flags-scaling	Process CPU time per operation	1.45 ms/op	1.46 ms/op	0.9% more time	Not flagged
Evaluate all 1,000 flags Shard: flags-scaling	Allocations per operation	33,113.59 count/op	33,113.62 count/op	<0.1% more	Not flagged
Evaluate all 1,000 flags Shard: flags-scaling	Time per operation	14.48 ms/op	14.4 ms/op	0.5% less time	Not flagged
Evaluate all 1,000 flags Shard: flags-scaling	Process CPU time per operation	14.48 ms/op	14.4 ms/op	0.5% less time	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Idle process memory (RSS)	39.71 MiB	39.27 MiB	1.1% less memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Observed peak process memory (RSS)	40.97 MiB	40.79 MiB	0.4% less memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Managed heap after settling	7.97 MiB	7.97 MiB	<0.1% more memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Process memory after settling (RSS)	39.47 MiB	39.27 MiB	0.5% less memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Lifetime peak process memory (RSS)	40.61 MiB	40.42 MiB	0.5% less memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Idle process memory (RSS)	38.04 MiB	37.44 MiB	1.6% less memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Observed peak process memory (RSS)	41.28 MiB	41.36 MiB	0.2% more memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Managed heap after settling	9.48 MiB	9.48 MiB	<0.1% more memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Process memory after settling (RSS)	41.24 MiB	40.94 MiB	0.7% less memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Lifetime peak process memory (RSS)	41.28 MiB	41.36 MiB	0.2% more memory	Not flagged
Evaluate one boolean flag Shard: flags-single	Allocations per operation	38 count/op	38 count/op	No observed change	Not flagged
Evaluate one boolean flag Shard: flags-single	Time per operation	10.39 µs/op	10.33 µs/op	0.5% less time	Not flagged
Evaluate one boolean flag Shard: flags-single	Process CPU time per operation	10.39 µs/op	10.33 µs/op	0.5% less time	Not flagged
Evaluate a cohort-filtered flag Shard: flags-single	Allocations per operation	38 count/op	38 count/op	No observed change	Not flagged
Evaluate a cohort-filtered flag Shard: flags-single	Time per operation	14.36 µs/op	14.35 µs/op	<0.1% less time	Not flagged
Evaluate a cohort-filtered flag Shard: flags-single	Process CPU time per operation	14.36 µs/op	14.35 µs/op	<0.1% less time	Not flagged
Evaluate a flag (early match) Shard: flags-single	Allocations per operation	55 count/op	55 count/op	No observed change	Not flagged
Evaluate a flag (early match) Shard: flags-single	Time per operation	18.01 µs/op	18.09 µs/op	0.5% more time	Not flagged
Evaluate a flag (early match) Shard: flags-single	Process CPU time per operation	18.01 µs/op	18.09 µs/op	0.5% more time	Not flagged
Evaluate a flag (late match) Shard: flags-single	Allocations per operation	76 count/op	76 count/op	No observed change	Not flagged
Evaluate a flag (late match) Shard: flags-single	Time per operation	25.46 µs/op	25.54 µs/op	0.3% more time	Not flagged
Evaluate a flag (late match) Shard: flags-single	Process CPU time per operation	25.46 µs/op	25.54 µs/op	0.3% more time	Not flagged
Evaluate a flag (no match) Shard: flags-single	Allocations per operation	67 count/op	67 count/op	No observed change	Not flagged
Evaluate a flag (no match) Shard: flags-single	Time per operation	22.84 µs/op	22.89 µs/op	0.2% more time	Not flagged
Evaluate a flag (no match) Shard: flags-single	Process CPU time per operation	22.84 µs/op	22.89 µs/op	0.2% more time	Not flagged
Evaluate a property-filtered flag Shard: flags-single	Allocations per operation	34 count/op	34 count/op	No observed change	Not flagged
Evaluate a property-filtered flag Shard: flags-single	Time per operation	10.59 µs/op	10.74 µs/op	1.5% more time	Not flagged
Evaluate a property-filtered flag Shard: flags-single	Process CPU time per operation	10.59 µs/op	10.74 µs/op	1.5% more time	Not flagged
Evaluate a regex-filtered flag Shard: flags-single	Allocations per operation	99 count/op	99 count/op	<0.1% more	Not flagged
Evaluate a regex-filtered flag Shard: flags-single	Time per operation	31.68 µs/op	31.56 µs/op	0.4% less time	Not flagged
Evaluate a regex-filtered flag Shard: flags-single	Process CPU time per operation	31.68 µs/op	31.56 µs/op	0.4% less time	Not flagged
Evaluate a rollout flag Shard: flags-single	Allocations per operation	31 count/op	31 count/op	No observed change	Not flagged
Evaluate a rollout flag Shard: flags-single	Time per operation	9.45 µs/op	9.38 µs/op	0.8% less time	Not flagged
Evaluate a rollout flag Shard: flags-single	Process CPU time per operation	9.45 µs/op	9.38 µs/op	0.8% less time	Not flagged
Evaluate a multivariate flag Shard: flags-single	Allocations per operation	37 count/op	37 count/op	No observed change	Not flagged
Evaluate a multivariate flag Shard: flags-single	Time per operation	11.83 µs/op	11.71 µs/op	1% less time	Not flagged
Evaluate a multivariate flag Shard: flags-single	Process CPU time per operation	11.83 µs/op	11.72 µs/op	1% less 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 81093eaf8199fee1330758bb9940a4d17b2acfdc → 39404bc02f0cdb9b42f0354e48c4c3d8cac0629c.

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.

[posthog]

PostHog Review · Standard · reviewed c8c6241: 1 Should fix.

See this review and its findings in PostHog Review. Comment @posthog review --deep for a Deep review. A Deep review takes longer and looks deeper than a Standard review.