What teams use Telflo for

Every claim on this page links to its source: the GitHub issues, survey data, and incident reports are one click away.

Cut the bill

Cut the data nobody looks at

Everyone in the channel agrees the DEBUG logs are junk nobody reads. The filter PR still sits open a month later, because nobody wants to be the one who approved dropping data an incident later needed.

An engineer on Hacker News described what happened after cost pressure switched sampling on at a previous job: at the next incident, "we had no idea if it was even logged."

With Telflo

Build the filtering in Telflo: drop the noise, tail-sample so every error trace survives, and aggregate the high-cardinality metrics. Then test it against sample traffic to confirm exactly what gets dropped and what stays, before the config ships.

Telemetry you pay to ingest
Sent today
After filters
tail sampling onerror traces kept: 100%
Protect uptime

Test a pipeline change the way you'd test code

A one-line edit to a sampling policy lands in a 700-line collector.yaml. CI passes, because the check only proves the YAML parses. The reviewer scrolls, tries to work out which of three pipelines the processor is wired into, and approves. Nobody finds the problem until production, when someone asks where the checkout traces went.

The stock tooling can't do better. Running a pipeline against data and checking the output is an open feature request in the Collector repo, filed in March 2024.

With Telflo

Telflo is that missing test harness. Feed sample telemetry through your actual config and check what comes out: error spans still reach the exporter, and drop rules only remove what you intended. Tests are saved with the config and rerun on every change. When they pass, push to the fleet over OpAMP.

checkout-pipeline · tests3 / 3 passed
error spans reach otlp/tempo
http.url rewritten to url.full
debug logs dropped before export
Pushed to 12 collectors via OpAMP
Consolidate backends

Migrate backends without getting stuck halfway

Six weeks into a migration, every pipeline still has two exporters: the old vendor and the new one. Finance wants to know why the old bill hasn't moved. Nobody deletes the old exporter, because nobody can prove the new backend sees everything the old one did. So the migration stalls, and you keep paying for both.

With Telflo

Telflo gives you one canvas for the routing: add the new exporter beside the old one, dual-ship from the same pipelines, and canary the cutover region by region over OpAMP. Before you flip, compare what both backends receive and catch mid-migration drift, like half the fleet emitting url.full while the other half still sends http.url. Then retire the old exporter and stop paying for the old backend.

one pipeline, two backends
traces
otlp/old-vendorotlp/new-backend
outputs match · safe to cut over
Prove compliance

Mask PII data

An engineer writes a card-number regex for the redaction processor. The config loads, the collector starts, and nothing anywhere says whether a real card number would come out masked. Someone asked exactly that in the OpenTelemetry repo, full config attached. The discussion has zero replies.

Most teams find out after the fact. One engineer on Hacker News described PII flowing into logs for a month before anyone noticed, then spending three days deleting it record by record.

With Telflo

OpenTelemetry's own docs hand you the processors (redaction, transform, filter) and remind you that as the implementer, you are responsible for what leaves the host. Telflo lets you verify it: run sample logs shaped like your real ones through the masking rules and confirm the card number comes out masked. Save the passing run and show it to your auditor when they ask for proof.

redaction · sample log in, masked log out
in POST /pay card=4111111111111111
out POST /pay card=****
masked · verified
Avoid lock-in

Your config leaves with you

Your vendor raises the price at renewal, and someone asks what it would take to switch. If the vendor's SDK is embedded in every service, the answer is a re-instrumentation project, so you sign the renewal. Teams adopt OpenTelemetry to escape exactly this: freedom to switch vendors is the second most cited reason for adopting it in Grafana's latest survey.

Some pipeline tools bring the lock-in back by making you write configs in their own proprietary format, one that compiles to OTel instead of being OTel.

With Telflo

Telflo has no house format. The canvas reads and writes standard Collector YAML: import the config you run today, export everything back out whenever you like. Route to any backend, or to two while you evaluate a replacement. If you ever leave Telflo, you leave with the exact YAML your fleet is already running.

collector.yaml · adding a backend
exporters:
otlp/grafana: ...
+otlp/honeycomb: ...
standard OTel YAML · import and export any time
Give engineers their time back

Stop hand-editing collector YAML

Hand-editing collector config means one typo can take the whole pipeline down. You change one setting, restart, and the collector refuses to start, with an error that names no file and no line number. That error has been a known problem since December 2024, so you find the typo by trial and error, which can take hours.

And the files only grow. Real configs run 600 lines and up, and every environment keeps its own slightly different copy. Code reviews of files that size, as one observability shop put it, "become exercises in scrolling." That adds up to a lot of senior engineering time going into a text file.

With Telflo

Telflo puts a canvas over the config. Components are forms with schema validation and inline docs, pipelines are laid out visually, and a small change is easy to see and review. Underneath, it is still your YAML: generated clean, diffable, exportable.

the same pipeline, on the canvas
otlpfilterotlp/tempo
0 validation errors
35+ components receivers, processors, and exporters with validated config forms in Telflo today
How Telflo fits

A control plane in the literal sense

Telflo speaks OpAMP to your collectors. It delivers config, watches health, and rolls back when something looks wrong. Your telemetry flows from your services through your collectors to your backends, on your own network. Telflo manages what the collectors run.

  • What you write is what runs. The editor reads and writes upstream Collector YAML, so a config built in Telflo runs anywhere the Collector runs.
  • OpenTelemetry graduated from the CNCF in May 2026 with the second-highest velocity of any project after Kubernetes. Telflo builds on it directly, with nothing proprietary layered on top.
  • Config in, config out. Import the pipeline you run today and export everything back out whenever you want.
Only in Telflo

Unit tests for telemetry pipelines

Most of what's on this page, any good pipeline tool should do. Testing is different: no other OTel tool runs your config against sample data and checks the output before you deploy. The gap is well documented.

The state of the art

"As far as I can tell, the only way to verify the behavior of an otelcol pipeline is to run the collector, wait for data to pass through, and manually verify that telemetry is showing up."

Pipeline unit test feature request, open in the Collector repo since March 2024
The built-in check

otelcol validate describes itself as "basic validation" in the Collector's own source. It confirms your components are wired up. Its authors note that subtler invalid cases get through.

opentelemetry-collector, otelcol/config.go
How it goes wrong

In December 2024, a telemetry service rollout took ChatGPT, the API, and Sora down for over four hours. The change had passed testing in a staging environment.

OpenAI incident report, Dec 2024

Telflo closes this gap with pipeline tests: sample telemetry in, assertions on what comes out, run before every deploy.

Start with the config you already run

Create a free account, import your collector.yaml, and see what you could cut. Everything stays standard OTel YAML.