Catch the Segfault, Skip the Syscall

Removing C++ exceptions from the sampling path cut overhead 15%, and interning strings cut another 25%. Neither was enough. Reservoir sampling of tasks was ruled out because building the dependency tree requires metadata for every task anyway.

The bigger change was a protected memcpy. The sampler installs SIGSEGV/SIGBUS handlers with sigaction. When not armed, they forward signals to the previously installed handler. try_memcpy arms the handler, and on a fault jumps to a recovery instruction pointer and returns an error. Faults are expensive but rare: code objects are effectively immortal and tasks outlive a single copy. The non-fault path costs about the same as a plain memcpy. The hard parts were coexisting with other handlers such as faulthandler and staying async-signal-safe. This alone cut sync overhead by about 50%. Across services where the changes rolled out, overhead fell more than 60%, and sampling frequency was no longer stuck at the 1 Hz floor.

In production, the new profiles found an infinite loop in pylzstr on malformed input, which was causing uvicorn worker kills. They also found a library building large log.debug strings for an INFO-level logger, which explained CPU spikes the team had seen but never traced.

What changed: Challenge Pages

Cloudflare now runs the same background test on a small fraction of free Challenge Pages. These are Turnstile-delivered gate pages, usually triggered by WAF rules, that check the browser for signs of automation before letting a visitor through. The test fetches from a fixed set of endpoints and records whether each request completed and how long it took. Cloudflare says it is designed to add no noticeable latency, and that it will raise the sampling rate only if data quality improves and users see no slowdown.

The gain is reach: many more samples, from more networks, including networks outside the top 1,000. That allows analyses a count of networks can't support, such as weighting by number of users, grouping by country, and estimating what share of traffic the measured networks represent.

Read the headline number with care

The author is open about the mechanism. In many networks the top providers are only 1–2 ms apart, for example Cloudflare at 50 ms vs Fastly at 51 ms, close enough that day-to-day noise can flip the ranking. The post says Cloudflare "may have previously ranked second" in such networks. More samples narrow the confidence intervals, and the post credits that for the improvement. No confidence intervals are published, though. Some of the 14-point gain is likely ties being decided by less noise rather than speed gained. There is also a small mismatch in the numbers: 14 points of 1,000 is 140 networks, but the post says 150. The gap is probably net of networks lost, but the post doesn't explain it.

Fowler ties this to the twelfth agile principle: "At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly." The defaults themselves are also reviewed regularly. Fowler calls that review the heart of the Thoughtworks Technology Radar.

The entry ends with a note on where the term came from. Fowler found a post on sensible defaults by Steve Bennett, written around the time Bottcher talked to Ross. He doesn't know whether Ross got the name from Bennett or whether the phrase appeared independently.

The piece is short and argues for no particular practice. What it offers is vocabulary: a way to set team standards that keeps the case for consistency and still makes exceptions something you argue for openly.

In a 2025 retrospective, Head of Mobile Mustafa Ali reported:

• P75 screen loads under 500ms
• More than 99.9% crash-free sessions
• No more work spent keeping iOS and Android at feature parity
• Hot reloading, which replaced native compile cycles that took several minutes even for trivial changes

The costs were real too. Debugging was flaky, the app depended on more third-party libraries, and native code was still needed for heavy animations, background jobs and widgets.

What changed

Ali argues that coding agents now handle enough of the implementation, translation between platforms, testing and review that building every feature twice "is no longer the deciding factor." Meanwhile, RN's structural cost hasn't gone away. RN keeps a React Host Tree that maps onto a native Host View Tree, which adds a layer between app code and UIKit or Jetpack Compose. The 2024 New Architecture didn't close that gap much. When Shopify migrated its Shopify and Point of Sale apps, startup got about 10% faster on Android and 3% on iOS, and some complex screens got slower until the team tuned them.

To stop the two codebases from drifting apart, Shopify is building a shared verification test suite. The same business-logic tests run against both the Swift and Kotlin implementations, headless on desktop, and a feature can't ship until it passes on both. Shopify keeps its single team model: one engineer builds a feature on both platforms. Engineering head Farhan Thawar puts it this way: "React, as the shared language, is now replaced by the English language."

Progress so far: the Shop app shipped fully native after 12 weeks, and the main Shopify app is in progress. Ali says each rebuild must meet or beat current performance, stability and accessibility. Thawar expects startup time and responsiveness to improve once the migration is done. There are no measurements yet to back that up.

Orosz notes that Airbnb made the same round trip between 2016 and 2018, also for performance reasons. He suggests Kotlin Multiplatform, which shares business logic while keeping each platform's UI native, may gain ground as a middle path.

• Security rules: when custom or managed rules ran, how long evaluation took, and the action taken. Span events name the rule behind a block or challenge.
• Transforms: the http_request_transform span lists each rewrite, the request component it touched, the rule responsible, and where it happened relative to routing.
• Routing: workers_routing shows whether a route matched, the routing type, and the matching pattern.
• Cache and origin: nested cache, upstream, and origin spans split out where the time went. In the post's example, a cache miss spent 527 ms of a 539 ms request waiting on origin.

Cloudflare says its internal traces often run to thousands of spans from dozens of services. The public version is a curated subset of those.

Sampling, propagation, export

You set a baseline sampling rate for the domain, such as 1%. Trace Rules override it for matching traffic and use the same Rules language as the rest of Cloudflare's config. That lets you trace 100% of requests for one customer's hostname, source IP, or a temporary debug header while everything else stays at the baseline. It's a practical way to reproduce a reported issue without raising tracing volume across the whole domain.

For distributed tracing, Cloudflare can accept an incoming W3C traceparent header, controlled by an incoming propagation policy, so its spans join a trace that started upstream. It can also forward a new traceparent to your origin, so downstream services continue the same trace. You configure OTLP export once per account as a destination, then choose which domains send to it. To see one connected trace, send both Cloudflare and application spans to the same backend.

One gap matters today: accepting context is all-or-nothing under the policy. "Authenticated context propagation", which would let only trusted callers continue an existing trace, is still on the roadmap. Also planned are more spans (DDoS, Access, Queues, Workflows), on-demand tracing of a single request, and 365-day retention.

Pricing starts December 1, 2026 and is based on bytes, not span counts. The free plan includes 0.5 GB of ingestion per day with 7-day retention. Paid plans include 50 GB of ingestion and 10 GB-month of storage, then charge $0.25/GB ingested and $0.10/GB-month stored.