SimpleSpanProcessor or BatchSpanProcessor: trading request-thread latency for telemetry loss under concurrent load

Under concurrent request load, OpenTelemetry SDK span processors force a documented trade-off between request-path latency and telemetry completeness. SimpleSpanProcessor exports each span synchronously on the thread that ends it, keeping telemetry latency low but adding export overhead directly to concurrent request handling. BatchSpanProcessor queues spans for a background thread, decoupling telemetry from request latency, but introduces a bounded queue that silently drops spans when full.

The goal is to minimize end-to-end request latency while preserving complete telemetry under sustained concurrency. The uncertainty is that the SDK offers no adaptive middle ground: operators must choose between blocking request threads with SimpleSpanProcessor or accepting telemetry loss with BatchSpanProcessor under saturation. Both processors preserve context propagation semantics, so the latency divergence stems from export scheduling rather than trace correlation.

Default queue sizes, batch limits, and drop policies vary by language SDK, so the exact saturation point differs across implementations. Concurrent latency may also originate from exporters, network I/O, or downstream collector capacity rather than the processor alone.

• Under identical concurrent load, does SimpleSpanProcessor's synchronous export add measurable request latency compared to BatchSpanProcessor's background export, or does queue saturation risk dominate the trade-off?
• Which language-specific SDK defaults for queue size and drop policy determine whether BatchSpanProcessor silently discards spans before the request path is affected?
• If neither blocking request threads nor dropping spans is acceptable, what documented configuration or processor combination offers a middle ground without modifying SDK internals?