September 2026

Welcome to the September 2026 edition of the OpenTelemetry News!

The Kubernetes attributes processor, a cornerstone of most Collector deployments running in Kubernetes, has reached its v1.0.0 stability milestone. This year's Governance Committee election is now open for nominations, and OpenTelemetry Rust's OTLP exporters for logs and metrics are one release away from being declared stable. On the Collector side, releases 0.160.0, 0.161.0, and 0.162.0 give the young dynamic_sampling processor a new name and yet another round of configuration changes, ship the new signing and rolling_span_latency processors, and retire resource_to_telemetry_conversion in favor of resource_constant_labels across the Prometheus exporters. Specification v1.61.0 adds composable View matching to the metrics SDK and stabilizes more of the Prometheus compatibility spec.

Highlights

The Kubernetes attributes processor reaches v1.0.0

The Kubernetes attributes processor, which enriches telemetry with Kubernetes metadata such as pod, deployment, and node attributes, has officially moved to v1.0.0. The promotion shipped in Collector v0.161.0, making the processor stable for traces, metrics, and logs (#49152). Being v1.0.0 means the component is verified to fulfill the project's stable criteria, covering testing, benchmarking, documentation, and telemetry stability, and it can now be redistributed as a Go library or as part of your binaries without API breakage.

The promotion comes with semantic convention changes enabled by default: the processor now emits stable attribute names like k8s.pod.label.* and stops emitting legacy plural forms such as k8s.pod.labels.*. If your pipelines or dashboards rely on the legacy names, the recommended path is dual emission during the transition, which you can configure through the processor's feature gates. Note also that the deprecated deployment_name_from_replicaset option was removed in the same release, and any configuration that still contains it now fails at startup (#45871).

2026 Governance Committee election

The 2026 Governance Committee election was announced on September 21. Nominations are due by October 16 at 23:59 AoE, and the list of eligible candidates will be shared on October 19. If you have been contributing to OpenTelemetry and want to help steer the project's direction, this is the window to put your name forward or nominate someone else.

OpenTelemetry Rust SIG update

The Rust SIG have been working toward declaring the OTLP exporters for logs and metrics stable. All outstanding gaps against the specification have been resolved, including complete retry behavior: OTLP/HTTP and OTLP/gRPC retries are now enabled by default with exponential backoff and jitter, with the option to opt out or provide a custom retry policy.

OpenTelemetry Rust 0.33.0, released on September 18, serves as the final release candidate for the OTLP exporters, and the team intends to declare them stable in 0.33.1 within the next week if no major issues arise. The 0.33.0 release notes cover the remaining breaking changes and the migration steps in detail.

New Collector releases

This news edition covers the OpenTelemetry Collector releases 0.160.0, 0.161.0, and 0.162.0.

Breaking changes

• Kafka deprecated options are removed and metadata behavior changes:
  • The deprecated auth.tls and auth.plain_text settings are gone from the Kafka exporter (#50202).
  • resolve_canonical_bootstrap_servers_only, auth.sasl.version, and group_rebalance_strategy are no longer accepted anywhere (#50381).
  • Configurations setting both auth.sasl and auth.kerberos are now rejected (#50748).
  • The default for metadata::retry::max changes from 3 to 20 to match franz-go's effective default, which only changes behavior for configurations that set the value explicitly now that it is finally applied, and metadata::retry::backoff is honored again after being silently ignored since the franz-go migration (#50116).
• The minimum Go version is now 1.26 for anyone building custom distributions from the Collector repositories (#50394).
• connector/signal_to_metrics changes its default error mode from propagate to ignore, so a single invalid item no longer drops the rest of a valid OTLP payload (#48419).
• Several log encoders flip to current semantic conventions by default (Each change can be reverted with the corresponding feature gates):
  • Azure log records now emit exception.message instead of the deprecated error.message (#50885).
  • The Google Cloud audit log parser stops emitting the deprecated rpc.jsonrpc.error_code and rpc.jsonrpc.error_message attributes (#50879).

Deprecations

• The Kafka receivers deprecate metadata::full, which has been a no-op since the franz-go migration (#50116).
• receiver/kubelet_stats deprecates the k8s.pod.cpu.node.utilization, k8s.pod.memory.node.utilization, k8s.container.cpu.node.utilization, and k8s.container.memory.node.utilization metrics following a decision by the Kubernetes semantic conventions SIG (#50857).
• The simpleprometheusreceiver is marked unmaintained and will eventually be removed from the community distributions unless new maintainers step up.

New components

• processor/signing: Signs each log record with an RFC 8785 (JCS) canonical hash, storing the signature as audit.integrity.value alongside audit.integrity.algorithm and audit.integrity.certificate resource attributes. Supports RS256, RS512, ES256, EdDSA, and HMAC-SHA256, and is designed for tamper-evident audit trails with the OpenTelemetry audit logging signal. Key material can be loaded from a file, environment variables, a Kubernetes Secret, or an OpenBao (Vault-compatible) engine (#50079, #50080, #51055). A heads-up for early adopters: the signed payload format changed twice this month, first including non-string bodies (#50911) and then wrapping scalar values in type-tagged objects so an int and a string with the same textual value no longer share a signature (#50884); signatures produced by earlier versions will not reproduce.
• processor/rolling_span_latency: Maintains an EWMA-based rolling latency baseline and labels spans as slow or very slow when they exceed it (#50260).

Component naming convention

The snake_case rename wave continued across v0.160.0, v0.161.0, and v0.162.0. Deprecated aliases are maintained so existing configurations keep working, but plan to update your component names to ensure compatibility with future releases. One exception below: the queuebatch rename keeps no alias, since the component is still in development stability.

OTTL & processing improvements

• pkg/ottl adds a clear function for removing values (#48714), Concat now accepts slice values produced by paths and converter expressions (#27821, #38690), and the transform processor gains extract_avg_metric to compute an average gauge from histogram data points (#49238).
• The set converter now writes nil values to the target instead of treating them as a no-op, promoted to beta in 0.161.0 and stable in 0.162.0 (#49741).
• The otelcol OTTL context is now always available, and the ottl.PanicDuplicateName gate is stable, so duplicate span or event names fail parsing instead of being silently allowed (#46437, #50873). The deprecated Base64Decode converter was removed; use Decode with the base64 encoding instead (#50875).
• processor/interval adds support for delta temporality metrics (#50845).

Sampling

• processor/adaptive_tail_sampling hardens against large traces and adds observability: a new span_limit (default 10,000) bounds per-trace buffering, so a single giant trace can no longer exhaust memory; a trace hitting the limit is decided immediately over the spans buffered so far, and a trace_span_count histogram plus an otelcol.processor.adaptive_tail_sampling.trigger attribute on kept spans make decision triggers visible. A record_fingerprint option stamps the matched rule's fingerprint on kept spans, hashed or raw, so grouping works fleet-wide (#49311). The cold-start sampling rate for adaptive_throughput is now explicit via initial_sampling_percentage (default 10), and new sampler_request_count, sampler_keyspace_size, and sampler_burst_count metrics expose the samplers' internal performance (#50538).
• processor/tail_sampling adds Trace State support for the rate_limiting and bytes_limiting policies (#49710).
• exporter/load_balancing adds a randomness routing key that routes spans by the OTel tracestate randomness value (ot=rv), falling back to trace ID randomness when absent (#49660).

Metrics & Prometheus compatibility

• The Prometheus exporters replace resource_to_telemetry_conversion with resource_constant_labels, which transforms OTLP resource attributes into Prometheus constant labels with included/excluded wildcard patterns, in line with the OTel Prometheus specification (#48861, #48862). The legacy option is deprecated, and the awsemf exporter's enabled/exclude_service_attributes fields deprecate in favor of the same pattern syntax.
• exporter/prometheus_remote_write now sends the start timestamp of cumulative sums, histograms, and summaries as start_timestamp when using the Remote Write 2.0 protobuf message (#50089).
• receiver/prometheus stops using the otel_scope_info metric for scope attribute extraction and converts it like any other metric; scope attributes are instead populated from otel_scope_-prefixed metric labels. The feature gate can no longer be disabled and will be removed in v0.164.0 (#47312).
• receiver/statsd adds the receiver.statsd.monotonicCounterDefault feature gate, which makes counters monotonic by default. Most statsd counters are monotonic, but the previous default produced non-monotonic delta sums that some exporters convert to gauges (#14956).

Kubernetes

• receiver/kubelet_stats now computes CPU usage metrics as the rate of the corresponding *.cpu.time counter between consecutive scrapes instead of reading the kubelet's UsageNanoCores value, which means these metrics are not reported on the first scrape after startup (#49477).
• receiver/k8s_cluster adds the k8s.statefulset.pod.available metric reporting available pods per stateful set (#50345).
• receiver/journald adds a convert_to_semantic_conventions option that maps well-known journald fields to semantic convention attributes (#7298).

Database receivers

• receiver/oracledb adds a db.server.top_procedure event with aggregated stored procedure performance metrics, correlated with db.server.top_query via oracledb.procedure_id (#50796), plus opt-in Automatic Storage Management diskgroup and disk metrics (#50487).
• receiver/sqlserver adds the same db.server.top_procedure event (#50799), moves oversized execution plans onto their own db.server.query_plan event so they can no longer drop the lightweight query statistics alongside them (#50629), and adds a db.system.version resource attribute (#51194).
• receiver/mysql adds health, query execution time, and active session count metrics (#50726), InnoDB redo log, checkpoint-age, history list, and active transaction metrics (#50650, #50380), and its own db.server.query_plan event (#51281).
• receiver/postgresql now reports non-relation locks in postgresql.database.locks; since every backend holds one virtualxid lock, check any dashboard that totals this metric (#49733). postgresql.table.size now reports total disk space including indexes (#50046).
• receiver/mongodb adds opt-in WiredTiger log, fsync, and transaction-ticket metrics (#50208) and replica set topology and oplog metrics (#50654).

Bug fixes

• exporter/prometheus now removes every series ended by a staleness marker when several arrive in the same metric, instead of leaving some behind (#51289), and receiver/prometheus drops malformed classic histograms with decreasing bucket counts instead of emitting invalid OTLP data (#50348).
• receiver/otlp_json_file fixes a panic and zeroed accepted-data counts caused by reading span and metric counts after the data was handed to the next consumer (#50314).
• extension/file_storage returns an error instead of crashing the Collector when bbolt database compaction fails during startup after database corruption (#49735).
• exporter/load_balancing removes stale Kubernetes endpoints when a relist recovers a missed watch deletion (#50741), skips routing to endpoints whose EndpointSlice conditions.ready is explicitly false (#50436), and avoids quadratic re-hashing when assembling per-endpoint metric batches, most visible with the streamID routing key on high-cardinality workloads (#49725).
• processor/k8s_attributes rejects an invalid exclude.pods[].name regex at config load instead of panicking at startup (#50957).
• connector/service_graph supports span links for asynchronous messaging correlation (#48610).

Datadog-related updates

• exporter/datadog:
  • The container.image.tags attribute is now mapped to the image_tag container tag, in addition to the deprecated container.image.tag; for now only the first element of the array attribute is extracted (#50864).
  • k8s.node.name attribute values are now mapped into kube_node (#50708).
  • Whitespace is now trimmed from the configured hostname (#50935).
  • The exporter emits running metrics for Azure workloads sending metrics through it: otel.datadog_exporter.metrics.running.azurecontainerapps for Azure Container Apps, tagged with replica, name, subscription_id, and resource_group (#49615), and running metrics for Azure App Services, Azure Functions, Cloud Run services, and Cloud Run Functions workloads (#51501).

OpenTelemetry specification v1.61.0

The v1.61.0 release adds composable View matching to the metrics SDK and continues stabilizing the Prometheus compatibility spec.

• MeterProvider gains a view_matching_mode parameter that makes View matching composable, so multiple Views can contribute to the same stream instead of a single winner being picked (#5173). maxExportBatchSize on the Periodic exporting MetricReader is marked stable, with its behavior, timeouts, and error handling clarified (#5291, #5265).
• A new AttributeValueDepthLimit bounds how deeply nested array and map attribute values may be (#5186), and the named service resource detector can fall back to platform-specific sources when OTEL_SERVICE_NAME is not set (#5280).
• The Prometheus exporter compatibility spec stabilizes its content negotiation and resource_constant_labels sections, and the transformation from OpenTelemetry Exponential Histograms to Prometheus Native Histograms with the standard exponential schema is updated (#5136, #5130, #5125).
• The global propagators requirement is relaxed from required to recommended (#5294).

Community news

Prometheus and OpenTelemetry interoperability survey results

The results of the Prometheus and OpenTelemetry interoperability survey are out. The survey asked users of both projects how they collect, process, and store metrics, aiming to understand with real usage data rather than assumptions how far the ecosystem has actually moved.

Interoperability is measurably easier than it was two years ago, but open-ended answers point to concrete remaining gaps (showing that there is still work to do on both sides), including data model differences, missing resource attributes and metadata, and naming and formatting friction.

Datadog news

Datadog OTLP Traces Intake Endpoint

The Datadog OTLP Traces Intake Endpoint is now generally available. With this endpoint, customers can send OpenTelemetry traces directly to Datadog over OTLP without running the Datadog Agent or the OpenTelemetry Collector, which makes it a good fit for environments where deploying extra infrastructure is impractical, from managed platforms such as Cloudflare, Vercel, and Heroku to serverless workloads.

The endpoint accepts OTLP HTTP with http/protobuf and http/json encoding (grpc is not supported) and authenticates with your Datadog API key in the dd-api-key header. Trace metrics are not computed by default for traces sent to the endpoint; pass compute_stats=true to enable them. For production Collector deployments, the existing setup with the datadog exporter remains the recommended path.

Making Rust observability reliable at scale with OpenTelemetry

As Datadog adopted Rust for performance-sensitive infrastructure, teams initially bolted OpenTelemetry exporters onto the tracing crate, which fragmented traces across mixed instrumentation, produced inconsistent sampling decisions across services, and drove up resource usage. The post explains why Datadog chose to build on OpenTelemetry rather than around it, and introduces dd-trace-rs, an open source Rust tracing library that wraps the OpenTelemetry Rust SDK with an opinionated configuration: standard Datadog environment variables, sampling aligned with Datadog's ingestion model, and a sampler that defers the final keep-or-drop decision until the whole trace has been observed. It also covers the upstream fixes the effort required, from rewriting OpenTelemetry's single-slot current-context representation as a proper stack, which made several context operations 2–4x faster as a side effect, to keeping the OpenTelemetry context synchronized with active tracing spans so combined setups no longer produce two separate traces for the same request. At Datadog scale, consistent sampling reduced trace ingestion volume by a factor of 20 while preserving the same observability signal.

Read the full post on the Datadog Engineering blog: Making Rust observability reliable at scale with OpenTelemetry.

Get involved

Want to contribute to OpenTelemetry? Here are some ways to get started:

• Join a Special Interest Group (SIG).
• Contribute code to one of OpenTelemetry repositories.
• Share your OTel story with the community.

Resources

• Datadog OpenTelemetry Documentation
• OpenTelemetry Documentation
• Getting Started Guide
• CNCF OpenTelemetry Slack

Did we miss something? If you have news to share or want to contribute to the next edition, please reach out to us via otel-news@datadoghq.com.