[marandaneto]

Motivation and context

Implements sdk-specs #211: detailed failed records are unevaluated, not healthy disabled flags.

• Failed direct reads return nil and report evaluation_failed with a null response; response-wide errors remain independent.
• Failed snapshot values/payloads are excluded from keys and capture enrichment; caller defaults work.
• Successful same-context local true/false/variant value/payload pairs survive failed remote fallback. Successful remote precedence, suppression and dedupe remain unchanged.
• Prior review fix retains existing local unresolved reasons after failed fallback. Healthy false resolves; remote-only failed keys do not invent local reasons.
• Latest review follow-up centralizes the existing wire literal in private FeatureFlagError::EVALUATION_FAILED and both producers.

No public API/dependency changes or new typed-v4 support. Existing SDK patch intent and release-tool-managed Rails dependency patch retained; no manual bump or release.

Scope limit: original snapshots still report evaluation_failed for a locally unresolved key with failed remote diagnostics, rather than the evaluate-flags inconclusive diagnostic. That existing telemetry divergence remains a separate contract follow-up, not a conformance claim.

How did you test it?

At signed commit 3627a97231ded3b9a04fde53bf6a18c3cefe161d, Ruby 4.0.7 / locked dependencies:

• Static constant extraction: identical focused specs pass before/after, 128 examples; literal wire assertions retained. Parent rerun also passed.
• Full suite: 2,526 examples, 0 failures, 49 optional pending.
• Full RuboCop: 167 files, no offenses. API snapshot and diff checks passed without regeneration.
• Earlier unresolved-reason fix has recorded genuine red/green; its regression remains green. No new behavioral-red claim for a constant extraction.
• Entire branch Authoring/deslop audit and exact-HEAD autoreview --mode branch --base origin/main: clean; TruffleHog clean.

No full Ruby/platform matrix, optional live OpenTelemetry/Rails integrations, gem build, benchmark or shared-harness claim. CI was not awaited.

Checklist

• Signed commits; full submitted diff reviewed.
• Useful regressions and literal telemetry assertions retained.
• Existing release intent retained; no API/version/lock change.

Agent context

Autonomy: Human-driven (agent-assisted). Human DRI and assignee: @marandaneto. Pi implemented the approved changes and ran the checks and isolated review above. Human review is required before merge; no auto-merge or release requested.

[github-actions]

posthog-ruby-sync Compliance Report

Date: 2026-11-13T09:17:42.069464+00:00
Duration: 56178ms

⚠️ 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	✅	6ms
Format Validation.Distinct Id Is String	✅	9ms
Format Validation.Token Is Present	✅	8ms
Format Validation.Custom Properties Preserved	✅	8ms
Format Validation.Event Has Timestamp	✅	7ms
Format Validation.Non Utc Event Timestamp Is Converted To Utc	✅	7ms
Retry Behavior.Retries On 503	✅	5308ms
Retry Behavior.Does Not Retry On 400	❌	7ms
Retry Behavior.Does Not Retry On 401	❌	6ms
Retry Behavior.Respects Retry After Header	✅	8012ms
Retry Behavior.Implements Backoff	❌	356ms
Retry Behavior.Retries On 500	✅	5156ms
Retry Behavior.Retries On 502	✅	5142ms
Retry Behavior.Retries On 504	✅	5116ms
Retry Behavior.Max Retries Respected	❌	566ms
Deduplication.Generates Unique Uuids	✅	18ms
Deduplication.Preserves Uuid On Retry	✅	5153ms
Deduplication.Preserves Uuid And Timestamp On Retry	✅	10270ms
Deduplication.Preserves Uuid And Timestamp On Batch Retry	✅	5163ms
Deduplication.No Duplicate Events In Batch	✅	18ms
Deduplication.Different Events Have Different Uuids	✅	10ms
Compression.Sends Gzip When Enabled	✅	6ms
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	❌	4ms
Error Handling.Does Not Retry On 413	❌	5ms
Error Handling.Retries On 408	✅	5145ms

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	✅	8ms
Request Payload.Flags Request Uses V2 Query Param	✅	8ms
Request Payload.Flags Request Hits Flags Path Not Decide	✅	8ms
Request Payload.Flags Request Omits Authorization Header	✅	8ms
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	✅	7ms
Request Lifecycle.No Flags Request On Init Alone	✅	2ms
Request Lifecycle.No Flags Request On Normal Capture	✅	6ms
Request Lifecycle.Two Flag Calls Produce Two Remote Requests	✅	9ms
Request Lifecycle.Mock Response Value Is Returned To Caller	✅	7ms
Retry Behavior.Retries Flags On 502	✅	108ms
Retry Behavior.Retries Flags On 504	✅	109ms
Side Effect Events.Get Feature Flag Captures Feature Flag Called Event	✅	9ms

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-13T09:18:31.752957+00:00
Duration: 98515ms

⚠️ 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	✅	108ms
Format Validation.Event Has Uuid	✅	107ms
Format Validation.Event Has Lib Properties	✅	109ms
Format Validation.Distinct Id Is String	✅	107ms
Format Validation.Token Is Present	✅	107ms
Format Validation.Custom Properties Preserved	✅	109ms
Format Validation.Event Has Timestamp	✅	108ms
Format Validation.Non Utc Event Timestamp Is Converted To Utc	✅	108ms
Retry Behavior.Retries On 503	✅	5413ms
Retry Behavior.Does Not Retry On 400	✅	2110ms
Retry Behavior.Does Not Retry On 401	✅	2110ms
Retry Behavior.Respects Retry After Header	✅	8116ms
Retry Behavior.Implements Backoff	✅	15612ms
Retry Behavior.Retries On 500	✅	5212ms
Retry Behavior.Retries On 502	✅	5214ms
Retry Behavior.Retries On 504	✅	5213ms
Retry Behavior.Max Retries Respected	✅	15623ms
Deduplication.Generates Unique Uuids	✅	111ms
Deduplication.Preserves Uuid On Retry	✅	5211ms
Deduplication.Preserves Uuid And Timestamp On Retry	✅	10316ms
Deduplication.Preserves Uuid And Timestamp On Batch Retry	✅	5216ms
Deduplication.No Duplicate Events In Batch	✅	112ms
Deduplication.Different Events Have Different Uuids	✅	108ms
Compression.Sends Gzip When Enabled	✅	106ms
Batch Format.Uses Proper Batch Structure	✅	107ms
Batch Format.Flush With No Events Sends Nothing	✅	5ms
Batch Format.Multiple Events Batched Together	✅	112ms
Error Handling.Does Not Retry On 403	✅	2112ms
Error Handling.Does Not Retry On 413	✅	2110ms
Error Handling.Retries On 408	✅	5211ms

Feature_Flags Tests

⚠️ 16/17 tests passed, 1 failed

View Details

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

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	108.68 µs/op	108.66 µs/op	<0.1% less time	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Idle process memory (RSS)	28.24 MiB	28.26 MiB	<0.1% more memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Observed peak process memory (RSS)	31 MiB	31.02 MiB	<0.1% more memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Managed heap after settling	5.28 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.24 MiB	30.26 MiB	<0.1% more memory	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Process CPU time per operation	19.25 µs/op	19.32 µs/op	0.4% more time	Not flagged
Capture and deliver events (32-byte payload, burst) Shard: capture	Lifetime peak process memory (RSS)	30.78 MiB	30.79 MiB	<0.1% more 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	108.56 µs/op	108.5 µs/op	<0.1% less time	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Idle process memory (RSS)	33.07 MiB	33.08 MiB	<0.1% more memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Observed peak process memory (RSS)	41.74 MiB	41.5 MiB	0.6% less memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Managed heap after settling	9.15 MiB	9.15 MiB	<0.1% more memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Process memory after settling (RSS)	38.85 MiB	39.18 MiB	0.8% more memory	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Process CPU time per operation	26.39 µs/op	26.52 µs/op	0.5% more time	Not flagged
Capture and deliver events (4,096-byte payload, burst) Shard: capture	Lifetime peak process memory (RSS)	41.56 MiB	41.37 MiB	0.5% 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.01 ms/op	1.01 ms/op	<0.1% more time	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Idle process memory (RSS)	28.18 MiB	28.15 MiB	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Observed peak process memory (RSS)	30.25 MiB	30.23 MiB	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Managed heap after settling	5.28 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.25 MiB	30.23 MiB	<0.1% less memory	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Process CPU time per operation	27.54 µs/op	28.65 µs/op	4% more time	Not flagged
Capture and deliver events (32-byte payload, steady) Shard: capture	Lifetime peak process memory (RSS)	30.25 MiB	30.23 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	<0.1% fewer	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Time per operation	1.01 ms/op	1.01 ms/op	<0.1% more time	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Idle process memory (RSS)	33.11 MiB	33.12 MiB	<0.1% more memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Observed peak process memory (RSS)	40.44 MiB	40.43 MiB	<0.1% less memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Managed heap after settling	9.15 MiB	9.15 MiB	<0.1% more memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Process memory after settling (RSS)	40 MiB	40.05 MiB	0.1% more memory	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Process CPU time per operation	31.92 µs/op	32.95 µs/op	3.2% more time	Not flagged
Capture and deliver events (4,096-byte payload, steady) Shard: capture	Lifetime peak process memory (RSS)	40.67 MiB	40.7 MiB	<0.1% more memory	Not flagged
Queue an event (32-byte payload) Shard: capture	Caller-thread CPU time per operation	8.43 µs/op	8.46 µs/op	0.4% more time	Not flagged
Queue an event (32-byte payload) Shard: capture	Time per operation	8.43 µs/op	8.46 µs/op	0.4% more time	Not flagged
Queue an event (4,096-byte payload) Shard: capture	Caller-thread CPU time per operation	8.37 µs/op	8.46 µs/op	1.1% more time	Not flagged
Queue an event (4,096-byte payload) Shard: capture	Time per operation	8.36 µs/op	8.46 µs/op	1.1% more time	Not flagged
Evaluate all 10 flags Shard: flags-scaling	Allocations per operation	343.02 count/op	343.02 count/op	<0.1% fewer	Not flagged
Evaluate all 10 flags Shard: flags-scaling	Time per operation	156.46 µs/op	157.25 µs/op	0.5% more time	Not flagged
Evaluate all 10 flags Shard: flags-scaling	Process CPU time per operation	156.46 µs/op	157.13 µs/op	0.4% more 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.49 ms/op	1.49 ms/op	<0.1% more time	Not flagged
Evaluate all 100 flags Shard: flags-scaling	Process CPU time per operation	1.49 ms/op	1.49 ms/op	<0.1% more time	Not flagged
Evaluate all 1,000 flags Shard: flags-scaling	Allocations per operation	33,113.62 count/op	33,113.59 count/op	<0.1% fewer	Not flagged
Evaluate all 1,000 flags Shard: flags-scaling	Time per operation	14.87 ms/op	14.89 ms/op	0.2% more time	Not flagged
Evaluate all 1,000 flags Shard: flags-scaling	Process CPU time per operation	14.87 ms/op	14.89 ms/op	0.2% more time	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Idle process memory (RSS)	38.81 MiB	38.81 MiB	<0.1% less memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Observed peak process memory (RSS)	40.92 MiB	40.51 MiB	1% less memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Managed heap after settling	7.98 MiB	7.98 MiB	<0.1% more memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Process memory after settling (RSS)	39.29 MiB	39.26 MiB	<0.1% less memory	Not flagged
Evaluate 1,000 flags under concurrent load Shard: flags-memory	Lifetime peak process memory (RSS)	40.52 MiB	40.16 MiB	0.9% less memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Idle process memory (RSS)	37.57 MiB	37.18 MiB	1% less memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Observed peak process memory (RSS)	41.39 MiB	41.45 MiB	0.1% 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.38 MiB	40.81 MiB	1.4% less memory	Not flagged
Refresh 1,000 flag definitions Shard: flags-memory	Lifetime peak process memory (RSS)	41.38 MiB	41.35 MiB	<0.1% less 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	11.87 µs/op	11.8 µs/op	0.6% less time	Not flagged
Evaluate one boolean flag Shard: flags-single	Process CPU time per operation	11.87 µs/op	11.8 µs/op	0.6% 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	18.69 µs/op	18.65 µs/op	0.2% less time	Not flagged
Evaluate a cohort-filtered flag Shard: flags-single	Process CPU time per operation	18.69 µs/op	18.65 µs/op	0.2% 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	22.9 µs/op	22.96 µs/op	0.2% more time	Not flagged
Evaluate a flag (early match) Shard: flags-single	Process CPU time per operation	22.9 µs/op	22.95 µs/op	0.2% 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	31.97 µs/op	31.67 µs/op	0.9% less time	Not flagged
Evaluate a flag (late match) Shard: flags-single	Process CPU time per operation	31.97 µs/op	31.67 µs/op	0.9% less 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	27.29 µs/op	27.52 µs/op	0.8% more time	Not flagged
Evaluate a flag (no match) Shard: flags-single	Process CPU time per operation	27.29 µs/op	27.51 µs/op	0.8% 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	13.38 µs/op	13.36 µs/op	0.2% less time	Not flagged
Evaluate a property-filtered flag Shard: flags-single	Process CPU time per operation	13.38 µs/op	13.36 µs/op	0.2% less time	Not flagged
Evaluate a regex-filtered flag Shard: flags-single	Allocations per operation	99 count/op	99 count/op	<0.1% fewer	Not flagged
Evaluate a regex-filtered flag Shard: flags-single	Time per operation	40.19 µs/op	40.71 µs/op	1.3% more time	Not flagged
Evaluate a regex-filtered flag Shard: flags-single	Process CPU time per operation	40.19 µs/op	40.71 µs/op	1.3% more 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	10.93 µs/op	10.91 µs/op	0.2% less time	Not flagged
Evaluate a rollout flag Shard: flags-single	Process CPU time per operation	10.93 µs/op	10.91 µs/op	0.2% 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	13.5 µs/op	13.64 µs/op	1% more time	Not flagged
Evaluate a multivariate flag Shard: flags-single	Process CPU time per operation	13.5 µs/op	13.64 µs/op	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 669aabfae651c88a3bf3a354ff0e876bc7576044 → 3627a97231ded3b9a04fde53bf6a18c3cefe161d.

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.

[veria-ai]

PR overview

No security issues were found in this pull request.

Reviews

• 3627a97 — No new issues
• 9e64251 — No new issues
• c00a32d — No new issues

[posthog]

PostHog Review · Standard · reviewed c00a32d: 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.

[ioannisj]

🤖 An AI agent wrote this on behalf of @ioannisj.

Nothing blocking from me. The direct reads, bulk reads and the local-then-remote fallback line up with the sdk-specs #211 scenarios, and I couldn't find a path where the new nil values crash or mislabel a healthy flag. One small suggestion inline about the new error string.