Skip to content

fix(mcp): send $mcp_initialize only for an initialize request - #342

Merged
lucasheriques merged 1 commit into
mainfrom
lucas/mcp-initialize-only-on-initialize
Nov 6, 2026
Merged

fix(mcp): send $mcp_initialize only for an initialize request#342
lucasheriques merged 1 commit into
mainfrom
lucas/mcp-initialize-only-on-initialize

Conversation

@lucasheriques

@lucasheriques lucasheriques commented Nov 6, 2026

Copy link
Copy Markdown
Contributor

Problem

PostHog::MCP sends $mcp_initialize on a session's first request of any kind, not only on initialize. A stateless HTTP server, or one that gets a lone tools/call, records a handshake that never happened. In a 60-thread run there were 21 $mcp_initialize events for 60 calls. The sdk-specs MCP spec ("Optional events") says $mcp_initialize is sent only for a client's initialize.

Changes

  • prepare_request no longer emits $mcp_initialize. The gem already records the real one when it handles initialize (dispatch_initialize -> record_initialize).
  • Removed the now-dead lazy path:
    • maybe_emit_initialize and the skip_initialize: parameter
    • the initialized-session tracking in tracking_data.rb
    • the spec that tested its claim race
  • Patch changeset: fewer $mcp_initialize events will arrive.

For reviewers:

  • posthog-ruby#332 passes skip_initialize: true on its unknown-tool path. Whichever PR merges second drops that argument in a small rebase.
  • The gem has no "initialize event" option yet, though the spec's Configuration table lists one. That's a separate change.

How I tested

  • 13 new examples, parameterized. A lone tools/call, tools/list, prompts/list, prompts/get, resources/list or resources/read sends no $mcp_initialize. initialize then tools/call sends exactly one. 12 concurrent first calls send none. 8 of the 13 failed before the fix.
  • bundle exec rspec spec/posthog/mcp: 212 examples, 0 failures.
  • bundle exec rspec: 2164 examples, 0 failures.
  • bundle exec rubocop and rake public_api:check are clean.

@lucasheriques
fix(mcp): send $mcp_initialize only for a client initialize request
fde3f65 
What: PostHog::MCP no longer emits a lazy $mcp_initialize from
prepare_request. The event now comes only from dispatch_initialize, for
an actual `initialize` request. Removed the now-dead initialized-session
tracking (claim/mark/session_initialized?) from TrackingData.

Why: the sdk-specs mcp-analytics spec forbids $mcp_initialize without an
initialize. A session's first tools/call (stateless HTTP, a lone call)
emitted one anyway; a 60-thread run sent 21 $mcp_initialize for 60 calls.

Tested with: bundle exec rspec spec/posthog/mcp (212, 0 failures);
bundle exec rspec (2164, 0 failures); bundle exec rubocop clean;
rake public_api:check passes. New parameterized specs failed first
(8 of 13): lone call per method, initialize then call, 12 concurrent
first calls.

Notes: the gem has no "initialize event" option today, so the spec's
option-off case is not covered here.
@lucasheriques
lucasheriques requested a review from a team as a code owner November 6, 2026 20:16
@github-actions

github-actions Bot commented Nov 6, 2026

Copy link
Copy Markdown

posthog-ruby-sync Compliance Report

Date: 2026-11-06T20:17:49.150056+00:00
Duration: 55901ms

⚠️ 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 ✅ 8ms
Format Validation.Event Has Uuid ✅ 5ms
Format Validation.Event Has Lib Properties ✅ 5ms
Format Validation.Distinct Id Is String ✅ 7ms
Format Validation.Token Is Present ✅ 6ms
Format Validation.Custom Properties Preserved ✅ 5ms
Format Validation.Event Has Timestamp ✅ 7ms
Format Validation.Non Utc Event Timestamp Is Converted To Utc ✅ 5ms
Retry Behavior.Retries On 503 ✅ 5375ms
Retry Behavior.Does Not Retry On 400 ❌ 6ms
Retry Behavior.Does Not Retry On 401 ❌ 5ms
Retry Behavior.Respects Retry After Header ✅ 8013ms
Retry Behavior.Implements Backoff ❌ 283ms
Retry Behavior.Retries On 500 ✅ 5111ms
Retry Behavior.Retries On 502 ✅ 5115ms
Retry Behavior.Retries On 504 ✅ 5116ms
Retry Behavior.Max Retries Respected ❌ 525ms
Deduplication.Generates Unique Uuids ✅ 14ms
Deduplication.Preserves Uuid On Retry ✅ 5160ms
Deduplication.Preserves Uuid And Timestamp On Retry ✅ 10263ms
Deduplication.Preserves Uuid And Timestamp On Batch Retry ✅ 5119ms
Deduplication.No Duplicate Events In Batch ✅ 15ms
Deduplication.Different Events Have Different Uuids ✅ 7ms
Compression.Sends Gzip When Enabled ✅ 5ms
Batch Format.Uses Proper Batch Structure ✅ 6ms
Batch Format.Flush With No Events Sends Nothing ✅ 2ms
Batch Format.Multiple Events Batched Together ❌ 14ms
Error Handling.Does Not Retry On 403 ❌ 4ms
Error Handling.Does Not Retry On 413 ❌ 4ms
Error Handling.Retries On 408 ✅ 5113ms

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 ✅ 7ms
Request Payload.Flags Request Hits Flags Path Not Decide ✅ 6ms
Request Payload.Flags Request Omits Authorization Header ✅ 6ms
Request Payload.Token In Flags Body Matches Init ✅ 6ms
Request Payload.Groups Round Trip ✅ 6ms
Request Payload.Groups Default To Empty Object ✅ 5ms
Request Payload.Disable Geoip False Propagates As Geoip Disable False ✅ 5ms
Request Payload.Disable Geoip Omitted Defaults To False ❌ 5ms
Request Payload.Flag Keys To Evaluate Contains Only Requested Key ✅ 5ms
Request Lifecycle.No Flags Request On Init Alone ✅ 2ms
Request Lifecycle.No Flags Request On Normal Capture ✅ 5ms
Request Lifecycle.Two Flag Calls Produce Two Remote Requests ✅ 8ms
Request Lifecycle.Mock Response Value Is Returned To Caller ✅ 5ms
Retry Behavior.Retries Flags On 502 ✅ 137ms
Retry Behavior.Retries Flags On 504 ✅ 137ms
Side Effect Events.Get Feature Flag Captures Feature Flag Called Event ✅ 8ms

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']

stamphog[bot]
stamphog Bot approved these changes Nov 6, 2026
View reviewed changes

@stamphog stamphog Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Approved.

The telemetry write-path change is disclosed and covered by current-head independent assurance. No outstanding review concerns or production-breaking issues were identified.

  • PostHog Review (Standard) reviewed the current head: no findings.
Gate mechanics and policy version
Gate Result
prerequisites ✓ all clear
deny-list ✓ no deny categories matched
size ✓ 58L, 2F substantive, 156L/5F incl. docs/generated/snapshots — within ceiling
tier ✓ T1-agent / T1d-complex (156L, 5F, cross-cutting, fix)
stamphog 2.7.0 .stamphog/policy.yml @ fde3f65 · reviewed head fde3f65

@github-actions

github-actions Bot commented Nov 6, 2026

Copy link
Copy Markdown

posthog-ruby-async Compliance Report

Date: 2026-11-06T20:18:20.618769+00:00
Duration: 98412ms

⚠️ 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 ✅ 110ms
Format Validation.Event Has Uuid ✅ 106ms
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 ✅ 107ms
Format Validation.Event Has Timestamp ✅ 107ms
Format Validation.Non Utc Event Timestamp Is Converted To Utc ✅ 9ms
Retry Behavior.Retries On 503 ✅ 5311ms
Retry Behavior.Does Not Retry On 400 ✅ 2109ms
Retry Behavior.Does Not Retry On 401 ✅ 2108ms
Retry Behavior.Respects Retry After Header ✅ 8118ms
Retry Behavior.Implements Backoff ✅ 15510ms
Retry Behavior.Retries On 500 ✅ 5212ms
Retry Behavior.Retries On 502 ✅ 5212ms
Retry Behavior.Retries On 504 ✅ 5214ms
Retry Behavior.Max Retries Respected ✅ 15617ms
Deduplication.Generates Unique Uuids ✅ 111ms
Deduplication.Preserves Uuid On Retry ✅ 5211ms
Deduplication.Preserves Uuid And Timestamp On Retry ✅ 10417ms
Deduplication.Preserves Uuid And Timestamp On Batch Retry ✅ 5214ms
Deduplication.No Duplicate Events In Batch ✅ 112ms
Deduplication.Different Events Have Different Uuids ✅ 108ms
Compression.Sends Gzip When Enabled ✅ 107ms
Batch Format.Uses Proper Batch Structure ✅ 106ms
Batch Format.Flush With No Events Sends Nothing ✅ 5ms
Batch Format.Multiple Events Batched Together ✅ 112ms
Error Handling.Does Not Retry On 403 ✅ 2109ms
Error Handling.Does Not Retry On 413 ✅ 2109ms
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 ✅ 106ms
Request Payload.Flags Request Omits Authorization Header ✅ 108ms
Request Payload.Token In Flags Body Matches Init ✅ 107ms
Request Payload.Groups Round Trip ✅ 107ms
Request Payload.Groups Default To Empty Object ✅ 107ms
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 ✅ 106ms
Request Lifecycle.No Flags Request On Init Alone ✅ 3ms
Request Lifecycle.No Flags Request On Normal Capture ✅ 105ms
Request Lifecycle.Two Flag Calls Produce Two Remote Requests ✅ 111ms
Request Lifecycle.Mock Response Value Is Returned To Caller ✅ 107ms
Retry Behavior.Retries Flags On 502 ✅ 237ms
Retry Behavior.Retries Flags On 504 ✅ 250ms
Side Effect Events.Get Feature Flag Captures Feature Flag Called Event ✅ 108ms

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

github-actions Bot commented Nov 6, 2026

Copy link
Copy Markdown

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 113.99 µs/op 114.22 µs/op 0.2% more time Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture		 Idle process memory (RSS) 28.39 MiB 28.4 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture		 Observed peak process memory (RSS) 31.16 MiB 31.16 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.27 MiB <0.1% less memory Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture		 Process memory after settling (RSS) 30.39 MiB 30.39 MiB No observed change Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture		 Process CPU time per operation 31.56 µs/op 31.38 µs/op 0.6% less time Not flagged
Capture and deliver events (32-byte payload, burst)
Shard: capture		 Lifetime peak process memory (RSS) 30.92 MiB 30.83 MiB 0.3% 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 114.12 µs/op 113.91 µs/op 0.2% less time Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture		 Idle process memory (RSS) 33.17 MiB 33.17 MiB <0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture		 Observed peak process memory (RSS) 42.36 MiB 42.37 MiB <0.1% more 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.62 MiB 40.66 MiB 0.1% more memory Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture		 Process CPU time per operation 44.48 µs/op 43.3 µs/op 2.7% less time Not flagged
Capture and deliver events (4,096-byte payload, burst)
Shard: capture		 Lifetime peak process memory (RSS) 42.21 MiB 42.14 MiB 0.2% 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.27 MiB 28.28 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture		 Observed peak process memory (RSS) 30.38 MiB 30.39 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture		 Managed heap after settling 5.27 MiB 5.27 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture		 Process memory after settling (RSS) 30.38 MiB 30.39 MiB <0.1% more memory Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture		 Process CPU time per operation 42.89 µs/op 43.6 µs/op 1.7% more time Not flagged
Capture and deliver events (32-byte payload, steady)
Shard: capture		 Lifetime peak process memory (RSS) 30.38 MiB 30.39 MiB <0.1% more 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% less time Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture		 Idle process memory (RSS) 33.08 MiB 33.07 MiB <0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture		 Observed peak process memory (RSS) 40.47 MiB 40.52 MiB 0.1% 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.24 MiB 40.21 MiB <0.1% less memory Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture		 Process CPU time per operation 52.13 µs/op 50.51 µs/op 3.1% less time Not flagged
Capture and deliver events (4,096-byte payload, steady)
Shard: capture		 Lifetime peak process memory (RSS) 40.79 MiB 40.81 MiB <0.1% more memory Not flagged
Queue an event (32-byte payload)
Shard: capture		 Caller-thread CPU time per operation 13.62 µs/op 13.66 µs/op 0.3% more time Not flagged
Queue an event (32-byte payload)
Shard: capture		 Time per operation 13.62 µs/op 13.66 µs/op 0.3% more time Not flagged
Queue an event (4,096-byte payload)
Shard: capture		 Caller-thread CPU time per operation 13.24 µs/op 13.76 µs/op 3.9% more time Not flagged
Queue an event (4,096-byte payload)
Shard: capture		 Time per operation 13.24 µs/op 13.76 µs/op 3.9% more 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 107.66 µs/op 105.82 µs/op 1.7% less time Not flagged
Evaluate all 10 flags
Shard: flags-scaling		 Process CPU time per operation 107.66 µs/op 105.81 µs/op 1.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.02 ms/op 1.01 ms/op 0.9% less time Not flagged
Evaluate all 100 flags
Shard: flags-scaling		 Process CPU time per operation 1.02 ms/op 1.01 ms/op 0.9% less 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 11.27 ms/op 11.08 ms/op 1.7% less time Not flagged
Evaluate all 1,000 flags
Shard: flags-scaling		 Process CPU time per operation 11.27 ms/op 11.08 ms/op 1.7% less time Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory		 Idle process memory (RSS) 39.34 MiB 39.29 MiB 0.1% less memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory		 Observed peak process memory (RSS) 40.93 MiB 40.87 MiB 0.2% 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.43 MiB 39.59 MiB 0.4% more memory Not flagged
Evaluate 1,000 flags under concurrent load
Shard: flags-memory		 Lifetime peak process memory (RSS) 40.58 MiB 40.66 MiB 0.2% more memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory		 Idle process memory (RSS) 38.02 MiB 38.1 MiB 0.2% more memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory		 Observed peak process memory (RSS) 41.24 MiB 41.45 MiB 0.5% more memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory		 Managed heap after settling 9.48 MiB 9.48 MiB <0.1% less memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory		 Process memory after settling (RSS) 41.24 MiB 41.36 MiB 0.3% more memory Not flagged
Refresh 1,000 flag definitions
Shard: flags-memory		 Lifetime peak process memory (RSS) 41.24 MiB 41.45 MiB 0.5% 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 6.69 µs/op 6.69 µs/op <0.1% more time Not flagged
Evaluate one boolean flag
Shard: flags-single		 Process CPU time per operation 6.68 µs/op 6.69 µs/op 0.2% more 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 8.37 µs/op 8.4 µs/op 0.4% more time Not flagged
Evaluate a cohort-filtered flag
Shard: flags-single		 Process CPU time per operation 8.37 µs/op 8.4 µs/op 0.4% more 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 11.32 µs/op 11.37 µs/op 0.4% more time Not flagged
Evaluate a flag (early match)
Shard: flags-single		 Process CPU time per operation 11.32 µs/op 11.37 µs/op 0.4% 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 15.93 µs/op 16.13 µs/op 1.3% more time Not flagged
Evaluate a flag (late match)
Shard: flags-single		 Process CPU time per operation 15.93 µs/op 16.13 µs/op 1.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 14.95 µs/op 15.27 µs/op 2.1% more time Not flagged
Evaluate a flag (no match)
Shard: flags-single		 Process CPU time per operation 14.95 µs/op 15.27 µs/op 2.1% 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 6.63 µs/op 6.77 µs/op 2.1% more time Not flagged
Evaluate a property-filtered flag
Shard: flags-single		 Process CPU time per operation 6.63 µs/op 6.77 µs/op 2.1% 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 17.84 µs/op 17.93 µs/op 0.5% more time Not flagged
Evaluate a regex-filtered flag
Shard: flags-single		 Process CPU time per operation 17.83 µs/op 17.93 µs/op 0.6% 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 6.01 µs/op 5.94 µs/op 1.1% less time Not flagged
Evaluate a rollout flag
Shard: flags-single		 Process CPU time per operation 6.01 µs/op 5.94 µs/op 1.1% 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 7.66 µs/op 7.43 µs/op 3% less time Not flagged
Evaluate a multivariate flag
Shard: flags-single		 Process CPU time per operation 7.66 µs/op 7.43 µs/op 3% 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 58f5335f895ebebc417bb4a48d22351ff96b5fb0 → fde3f65918d0183a8522af0a59b06fa9c64b2faa.

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.

@lucasheriques
lucasheriques merged commit eb7216a into main Nov 6, 2026
31 checks passed
@lucasheriques
lucasheriques deleted the lucas/mcp-initialize-only-on-initialize branch November 6, 2026 20:24
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@stamphog stamphog[bot] stamphog[bot] approved these changes

Assignees

No one assigned

Labels

stamphog

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

1 participant

@lucasheriques