Uh oh!
There was an error while loading. Please reload this page.
fix(cloudflare): Preserve late static child spans - #23428
Closed
betegon wants to merge 5 commits into
Closed
Conversation
Deferred segment capture needs to distinguish an event accepted by the client pipeline from one rejected by sampling, processors, hooks, or queue admission. Keep the decision internal, one-shot, and invisible to event hint consumers so existing callback contracts remain unchanged. Co-Authored-By: OpenAI/ChatGPT <codex@openai.com>
Late descendants must wait for their segment event to be accepted, otherwise dropped or rejected roots can leak orphan telemetry and accepted descendants can be duplicated. Track pending, accepted, and rejected subtrees with weak ownership and preserve exact local parentage across the deferred boundary. Co-Authored-By: OpenAI/ChatGPT <codex@openai.com>
Static Cloudflare request transactions can finish before work registered with waitUntil ends, which previously dropped those late child spans. Use the shared deferred-capture lifecycle so accepted late children remain traceable without changing streaming behavior. Co-Authored-By: OpenAI/ChatGPT <codex@openai.com>
Exercise the static lifecycle through a real Wrangler worker and fail if the late child is lost, embedded twice, or emitted more than once. The strict runner remains opt-in so existing integration suites keep their current envelope matching semantics. Co-Authored-By: OpenAI/ChatGPT <codex@openai.com>
Contributor
size-limit report 📦
|
A shared client can drain deferred transactions from several invocations in one callback. Re-enter each span's captured current and isolation scopes so event processing and runtime flush state remain attributed to the owning invocation. Co-Authored-By: OpenAI/ChatGPT <codex@openai.com>
betegon
commented
Aug 14, 2026
MemberAuthor
Closing this implementation after validating the MCP workload on deployed Cloudflare Workers. Using published The underlying static behavior remains, so #23427 is being closed as not planned rather than fixed. For the MCP/Cloudflare path, |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Preserves child spans which end after a Cloudflare static request transaction has already been sent. These spans are emitted exactly once on the same trace with their original parent instead of disappearing.
Root cause
Cloudflare did not enable the deferred segment-capture strategy already used by the Node SDK. Static transactions were therefore assembled as soon as the request segment ended, with no path for a child ending later in
waitUntil().Enabling the existing strategy directly was not sufficient. It treated spans as captured before the client event pipeline had accepted their transaction. If processing, a before-send hook, or queue admission rejected that event, pending descendants could still be emitted as ghost orphan transactions.
Design
Core now exposes an internal, one-shot terminal capture decision. Deferred segment capture reserves spans while that decision is pending:
Rejection is deliberately not retroactive: telemetry which has already passed its own pipeline remains accepted. The acceptance callback runs after the client processing-buffer slot has been released, so a follow-up capture does not incorrectly encounter a full buffer.
Cloudflare clients enable this strategy for static capture. A child ending after an accepted segment becomes a standalone transaction with the same trace ID, its exact original parent, and
sentry.parent_span_already_sent=true. Span streaming remains unchanged. There is no public API or MCP protocol change.Node already enables deferred segment capture, so the Core state-machine hardening also applies to its existing use of this machinery.
Relation to #23151
#23151 and its prerequisite #23136 solve a different part of the Cloudflare lifecycle: they reuse one client across invocations and eagerly drain envelopes and streamed-span trace buckets. This PR handles static transaction aggregation, where a late child cannot be added to a transaction which has already been sent. The two approaches are complementary.
A shared client can drain deferred static transactions from several invocations in one callback. Deferred capture therefore re-enters each span's captured current and isolation scopes before event processing, keeping processors,
InvocationState,sendEnvelope, andwaitUntilattached to the owning invocation. A combined checkout of both PRs reproduced both events under invocation B before this guard and A/B ownership after it. The committed Core regression protects current and isolation scope ownership without making this PR depend on #23151.When #23151 rebases after this PR, its
CloudflareClientconstructor must retain_INTERNAL_setDeferSegmentSpanCapture(this). The strategy remains inert for its default streamed lifecycle.Evidence
The bug was reproduced using baseline and patched SDK tarballs built from the same source SHA, with one pinned Worker fixture and a protocol-independent control:
2026-07-28late childThe exact patched local run emitted seven expected transaction envelopes with no duplicates. A personal Cloudflare deployment with byte-identical Cloudflare/Core artifacts reproduced the same topology in Sentry; the final artifact set also passed the protected remote smoke. A modern MCP request is only the workload which exposed the generic lifecycle failure.
The repository regression uses a real Wrangler/workerd Worker and strict envelope cardinality. The final causal source state passes the complete Core (
3361passed,14skipped), Node (352passed,3skipped), and Cloudflare (818passed) package suites. The modern Cloudflare MCP and legacyMcpAgentE2Es also pass in development and production modes; the Node MCP v2 control passed during the finalization cycle.The Cloudflare bundle remains below both size limits:
217731 Bminified and541040 Bunminified (limits215 KiBand529 KiB).Compatibility and risk
Only static segment capture changes. Static traces can gain one transaction event where a late child was previously dropped. Accepted children are not emitted twice, children pending beneath a rejected segment remain suppressed, and the state is weakly keyed and released at terminal decisions.
The branch is arranged as five dependent review commits: terminal event decisions, the Core state machine, Cloudflare activation, the real Worker regression, and shared-client scope ownership.
Fixes#23427