# Honeycomb is moving adaptive tail sampling into the OpenTelemetry Collector Honeycomb is donating a Refinery-derived adaptive tail-sampling processor to OpenTelemetry, aiming to make dynamic cost and coverage controls available in standard Collector pipelines rather than a vendor-specific proxy. The new processor can vary sample rates by trace fingerprint and target either a traffic percentage or throughput budget. It is usable now in Honeycomb’s Collector distribution, while the upstream OpenTelemetry component is still working toward alpha. - Status: Active - Published: 2026-09-04T16:54:55+12:00 - Updated: 2026-09-04T16:54:55+12:00 - Categories: Cloud & Infrastructure, Observability - Tags: Honeycomb, Observability, OpenTelemetry, tail sampling, telemetry sampling - Canonical HTML: https://beyondthe.news/dossiers/honeycomb-adaptive-tail-sampling-opentelemetry-collector ## What changed On September 1, Honeycomb announced that it is donating an adaptive tail-sampling processor to the OpenTelemetry Collector. The component brings techniques developed around Honeycomb’s open-source Refinery proxy into Collector pipelines: trace fingerprinting, dynamically adjusted sample rates, percentage or throughput targets, static keep/drop rules and sample-rate attribution. Honeycomb’s Collector distribution already bundles the processor, while Honeycomb says the upstream OpenTelemetry contribution is still working toward alpha. ## Why it matters Sampling is one of the main levers teams use to control telemetry volume and observability cost, but static or purely random policies can discard rare journeys while over-representing high-volume traffic. Adaptive sampling changes that trade-off by grouping traces into meaningful fingerprints and allocating the sampling budget across those groups. If the processor reaches standard OpenTelemetry distributions, teams could gain a more portable cost-control primitive without inserting a separate vendor-specific sampling service into the telemetry path. ## The sampler changes rates instead of applying one fixed percentage The processor can identify traces by attributes such as service names, HTTP routes, tenant IDs or status codes. It then adjusts the sample rate per fingerprint rather than treating every trace as equivalent, preserving more low-volume paths while sampling high-volume paths more aggressively. ## Teams can target percentage or absolute throughput Honeycomb documents two adaptive goals. `adaptive_percentage` aims to keep a chosen share of overall traffic, while `adaptive_throughput` aims for an approximate spans-per-second budget. Rates are recalculated on a configurable interval so a traffic spike does not automatically produce the same multiple of telemetry volume. ## Important traces can still bypass the adaptive budget Static rules run alongside adaptive rules. A pipeline can keep all traces containing errors or slow requests before applying adaptive sampling to the remaining traffic, which lets teams reserve full fidelity for known high-value cases. ## Sample-rate attribution is part of the design The processor emits OpenTelemetry sampling-threshold information through `tracestate`, allowing compatible backends to understand what each sampled trace represents and make more accurate extrapolations from sampled data. ## Upstream OpenTelemetry status is not production-ready yet Honeycomb’s own Collector distribution includes the component today, but the company says the upstream contribution is still moving toward alpha. Builders should treat the current Honeycomb distribution as the practical test path and avoid assuming the processor is already present or stable in official OpenTelemetry Collector images. ## Key details - Honeycomb announced the donation on September 1, 2026. - The processor is based on techniques from Honeycomb’s open-source Refinery tail-sampling proxy. - Supported concepts include trace fingerprinting, adaptive percentage targets, adaptive throughput targets, static rules and sample-rate attribution. - Honeycomb says adaptive rates recalculate as traffic changes rather than remaining fixed. - The Honeycomb Collector Distribution bundles the processor today. - The upstream OpenTelemetry component is still working toward alpha. ## Builder takeaways - If telemetry cost is currently controlled with a blanket percentage, test a fingerprint-based policy on representative traffic and compare rare-route coverage before changing production retention. - Define fingerprints around dimensions that represent genuinely different journeys—such as tenant, route and service path—rather than high-cardinality attributes that would fragment the sampling budget. - Keep deterministic rules for errors or other must-retain traces ahead of adaptive policies. - Pin the Honeycomb Collector distribution to a release rather than `latest` for production experiments, and track the upstream OpenTelemetry status before standardizing configuration across environments. - Verify how the destination backend handles OpenTelemetry sample-rate attribution before relying on extrapolated counts. ## What to watch - When the adaptive tail-sampling processor reaches alpha, beta and stable status upstream. - Whether official OpenTelemetry Collector distributions converge on the same configuration schema as Honeycomb’s current implementation. - How other observability backends consume and expose OpenTelemetry sampling-threshold attribution. ## Uncertainties - The upstream OpenTelemetry contribution has not yet reached alpha, so configuration and behaviour may change before it becomes a standard Collector component. - Honeycomb is the author of the announcement and the current implementation evidence; broader independent production experience is not yet available for the upstream component. ## Timeline - **2026-09-01 — Honeycomb announces OpenTelemetry donation:** Honeycomb publishes the adaptive tail-sampling processor design and a usable build in its Collector distribution. - **2026-09-04 — Upstream work remains pre-alpha:** Honeycomb’s published guidance still describes the processor as working toward alpha in the upstream OpenTelemetry Collector. ## Sources - [Bringing the Most Advanced Sampling to the OpenTelemetry Collector](https://www.honeycomb.io/blog/bringing-most-advanced-sampling-opentelemetry-collector) — Honeycomb · primary · 2026-09-01T00:00:00+12:00. Primary announcement explaining the donated processor, adaptive algorithms, configuration examples and upstream status.