Google Cloud recently unveiled broad support for the OpenTelemetry Protocol (OTLP) in Cloud Monitoring, marking a step toward unifying telemetry collection across its observability stack. With this rollout, users can now send metrics in OTLP format, alongside traces and logs, to Cloud Monitoring through a vendor-agnostic pipeline, enabling more flexible, standard-based instrumentation and simpler, more consistent telemetry ingestion.
The update builds on previous support for OTLP trace ingestion and underscores Google Cloud’s commitment to OpenTelemetry as a universal format and API for telemetry data. Developers can use OpenTelemetry SDKs to generate metrics, then send them via OTLP either directly to Cloud Monitoring or through an OpenTelemetry Collector. By default, ingested OTLP metrics are stored like Prometheus-formatted data and are fully queryable using standard Monitoring tools.
Support for OTLP metrics introduces several enhancements that improve observability workflows: delta-type metrics, which reduce client-side memory use by reporting only counter changes; exponential histograms for dynamic bucket sizing; and expanded naming conventions that embrace dots and slashes, enabling better alignment with standard OpenTelemetry semantic conventions. These features help bridge gaps between cloud-native instrumentation, third-party telemetry pipelines, and Google Cloud’s own monitoring infrastructure.
In addition to raw OTLP support, Google Cloud also announced Managed OpenTelemetry for Google Kubernetes Engine (GKE). This fully managed ingestion pipeline simplifies deploying, scaling, and operating OpenTelemetry Collectors for Kubernetes workloads. This offers a turnkey option for teams that need OTLP-driven observability without managing collector infrastructure.
For users, the new OTLP metrics support means less effort in instrumenting and configuring apps for observability: instrumentation code can remain vendor-agnostic, while Google Cloud handles scale and ingestion. It also aligns with a broader trend toward unified telemetry APIs, as seen in the upcoming rollout of a single unified ingestion endpoint (telemetry.googleapis.com) that will automatically become active in many Google Cloud projects, streamlining observability data flows for logs, traces, and metrics alike.
While Google Cloud’s new OTLP support in Cloud Monitoring significantly improves standards-based telemetry ingestion, other major observability platforms have also been moving toward broader OpenTelemetry compatibility, each with different trade-offs. For example, Amazon Web Services’ CloudWatch supports OTLP metrics and traces via its CloudWatch agent and OpenTelemetry exporters, allowing data to be collected and converted for native ingestion, but it often relies on additional configuration for full pipeline integration. Meanwhile, vendors such as Datadog and New Relic extend the OpenTelemetry ecosystem with their own agent distributions and collector integrations to blend OTLP telemetry with rich dashboards, analytics, and advanced alerting, although some implementations still mix proprietary processing with open standards for enhanced feature sets.
Beyond hyperscale cloud providers, open-source or hybrid observability tools like SigNoz and Grafana Cloud also leverage OTLP and the OpenTelemetry ecosystem to provide flexible, vendor-agnostic observability. These platforms emphasise interoperability and ease of use, often allowing deeper customization or self-hosting models that appeal to teams seeking to avoid vendor lock-in, albeit with trade-offs in enterprise-grade support or tightly integrated cloud services. In this landscape, Google’s approach emphasises native, OTLP support deeply integrated into its Cloud Monitoring stack, offering a simpler path for existing Google Cloud customers while aligning with industry efforts to make telemetry truly portable across tools.
Cloud Monitoring’s OTLP support is currently available in preview for customers using OpenTelemetry versions 0.140.0 or later, providing enterprises and cloud engineers with a more open, flexible, and future-ready observability foundation.
