OpenTelemetry (OTel) Development Speed: Why the CNCF Observability Standard Is Falling Behind

A developer named Mat Duggan built a spreadsheet tracking OpenTelemetry's (OTel) issue and pull request history, and the numbers point to an uncomfortable conclusion: the project that succeeded at vendor neutrality is now struggling to ship features at a pace its adopters expect. OTel is the de facto instrumentation standard in cloud-native environments, backed by the Cloud Native Computing Foundation (CNCF). Duggan's analysis argues the project's own process has become its biggest bottleneck.

What's Happening

A developer named Mat Duggan compiled a spreadsheet tracking OpenTelemetry's issue and PR history across its repositories, and the data tells an uncomfortable story: the project that succeeded at vendor neutrality is now struggling to ship features at the pace its adopters expect. OTel is the de facto standard for instrumentation in cloud-native environments, backed by the CNCF, but Duggan's analysis argues that its own process has become the bottleneck.

The Core/Contrib Split and the Approval Chain

OpenTelemetry's codebase is split into two tracks: Core and Contrib. Adding a single new capability isn't a matter of one pull request. It typically has to move through an OTEP (OpenTelemetry Enhancement Proposal), then a specification change, then semantic convention updates, then per-language SDK implementation, then instrumentation packages, then the Collector, and finally OTLP protocol support.

Each of those stages needs sign-off from a different set of maintainers, and OTel supports a wide matrix of languages and frameworks — Go, Java, Python, .NET, Node.js, Rust, and more — each with its own SDK and its own volunteer maintainers. Combine that with OTel's strict stability guarantees, which make maintainers cautious about touching anything already shipped, and you get a pipeline where a straightforward improvement can sit unresolved for months or years.

Why This Matters Beyond the Spreadsheet

OpenTelemetry isn't a niche tool. It's the instrumentation layer underneath a large share of modern observability stacks — commercial platforms like Datadog, New Relic, and Grafana all ingest OTLP data, and plenty of companies built in-house pipelines around OTel specifically to avoid vendor lock-in. That bet assumed the standard itself would keep moving fast enough to match the pace of the ecosystem it serves.

When feature delivery stalls, teams don't just wait patiently. They patch gaps with vendor-specific SDKs, write custom instrumentation, or delay migrating workloads to newer frameworks until support catches up. That quietly undermines the vendor-neutrality argument that got teams to adopt OTel in the first place — if you have to maintain in-house workarounds anyway, some of the portability benefit disappears.

Smaller-community languages and newer frameworks feel this most acutely, since they sit further back in the maintainer queue than Java or Python. Organizations that assumed CNCF backing meant a well-resourced, fast-moving project may need to revisit their instrumentation roadmaps with more conservative timelines.

The Takeaway

Duggan's spreadsheet doesn't prove OpenTelemetry is failing — vendor neutrality is a real, hard-won achievement. But it does put numbers behind a complaint that's circulated in observability circles for a while: the governance model that makes OTel trustworthy is the same one slowing it down. Whether the project simplifies its multi-stage approval process or brings in more maintainers is worth watching, especially for teams currently planning multi-year instrumentation strategies around it.

Reference: https://matduggan.com/otel-isnt-going-well-and-i-made-a-spreadsheet-about-it/

Comments

Popular posts from this blog

Why I Started Ignoring AI-Written Work Documents (And You Might Too)

US Justice Department Links AI and Data Center Opposition to Foreign Agent Rules

OpenAI AI Agent Breached Australia's Medicare Portal: What PM Albanese Revealed