Skip to content
stateless.co · Engineering notes from the request/response layer
statelessThe engineering desk

A publication about the machinery under everyday software: the contracts between services, the queries behind a page, and the failures that only show up in production.

—Archive

OpenTelemetry Stabilizes Metrics API: Simplifying Traces and Metrics Integration for Production

07 November 2026

Observability teams can now leverage OpenTelemetry's stable Metrics API to enhance production systems. With core components ready for integration and a mature protocol, organizations can now streamline metric collection, correlation with traces, and resource management. Supported language implementations are now established, but some components remain experimental. OpenTelemetry remains under active development, so keeping an eye on progress will be crucial for teams preparing for standard deployment.

What Is OpenTelemetry’s Metrics API?

The OpenTelemetry Metrics API represents a pivotal advancement in the realm of application performance monitoring. This API introduces a trio of central components: the MeterProvider, Meter, and Instrument. The MeterProvider, serving as the entry point, facilitates the creation of Meter objects, which in turn generate the Instruments responsible for collecting and reporting measurements. This architecture allows for the efficient capture of raw measurements while safeguarding the independence of the instrumentation from the underlying SDK.

The Importance of Stabilization

OpenTelemetry has marked the Metrics API as "stable," with the broader Metrics ecosystem categorized as "mixed." The Differentiating the stable API from the SDK and Protocol emphasizes the robust foundation laid for metrics observability. The Data Model, integral to the OpenTelemetry Protocol (OTLP), is standardized and production-ready. Language communities continue refining their implementations, with Rust recently declaring its Metrics SDK as officially stable, while JavaScript has achieved stability across Traces, Metrics, and Logs.

Why This Matters for Production Systems

Stabilization addresses critical concerns in production environments, such as memory management and resource optimization. OpenTelemetry's Metrics SDK employs cardinality limits, with a default threshold of 2000 per metric, to avoid unbounded memory use. This configuration, adjustable via the View API and `MetricStreamConfiguration.CardinalityLimit`, ensures efficient resource utilization. Furthermore, the reuse of Meter objects to avoid excessive expense promotes scalable and high-performance metric collection practices.

Integration with Traces

A key OpenTelemetry design goal is the seamless integration of metrics with traces. This enables teams to correlate metrics with trace data using exemplars, ensuring a holistic view of application performance. The consistent Resource model across logs, metrics, and traces further unifies observability efforts, making it easier to pinpoint and resolve issues. This interoperability extends to existing paradigms, with support for Prometheus and the ability to collect StatsD metrics using the OpenTelemetry Collector.

Language Implementations and Collector Progress

As of 0.30, OpenTelemetry Rust has declared the Metrics SDK stable, while `opentelemetry-otlp` remains in Release-Candidate status. The OpenTelemetry Collector, with "mixed" status, offers experimental metric pipelines and developing Prometheus support in collaboration with the broader Prometheus community. These advancements collectively represent a substantial stride towards comprehensive, integrated observability across the ecosystem.

Implications for Teams

With the Metrics API stabilized, teams can now harness OpenTelemetry's capabilities for more efficient, integrated observability in production. However, the mixed SDK status and ongoing development call for cautious deployment. As systems evolve, teams should remain mindful of the current limitations, particularly around experimental features and maturing language implementations.

In Conclusion

OpenTelemetry's stabilized Metrics API represents a notable milestone in the observability landscape, offering a robust foundation for efficient metric collection and trace integration. While the API provides a reliable starting point, the ongoing refinement of SDKs and the experimental nature of certain features indicate a need for deliberate, phased adoption. As OpenTelemetry continues maturing, its metrics capabilities promise to be integral to the observability strategies of forward-thinking organizations, facilitating deeper insights and proactive issue resolution in complex, production-ready environments.