The tracing pipeline on Grafana Labs

The four-stage tracing pipeline

Tue, 04 Aug 2026 18:58:09 -0400

The four-stage tracing pipeline

Tracing isn’t a single product. Getting a trace from your application onto your screen takes several separate pieces: one produces the spans, one moves them, one stores them, and one reads them. Out of context, their names blur together.

This section is the map that puts those pieces in order. Every trace follows the same path, from your application to your screen. That path, from producing a trace to reading it, is the tracing pipeline, and it has four stages:

Instrument: your application produces spans as it handles a request.
Send: those spans travel from your application to where they’re stored.
Store: the spans are saved together as a trace so you can find them later.
Query and visualize: you find a trace and read it to see where the request spent its time.

Each of these steps is one pipeline stage: one link in the path a trace takes.

The four stages run in order, each handing the trace to the next:

One tool per stage

The next three slides walk the first three stages in order and introduce the main tool at each one. The fourth stage, finding and reading a trace, is where the rest of the journey is headed: you’ll do it hands-on in the next section.

Stage 1, Instrument: where spans come from

Tue, 04 Aug 2026 18:58:09 -0400

Stage 1, Instrument: where spans come from

A trace has to start somewhere. Before your application can produce spans, it needs code that watches its work and records each unit of that work as a span. Adding that code or tooling is called instrumentation.

Most teams instrument with OpenTelemetry

You don’t have to write that recording code by hand. Most teams instrument with OpenTelemetry, an open, vendor-neutral standard for generating traces, and other signals, from application code. Because it’s a shared standard rather than one vendor’s format, the traces it produces work with many backends, not just one.

Setting it up comes later

This journey doesn’t instrument an application. Choosing how to instrument your code and wiring it up is part of setup, covered in the separate setup journey and the instrumentation documentation. Here, you only need to know that spans come from an instrumented application at the start of the pipeline.

Stage 2, Send: a collector moves your spans

Tue, 04 Aug 2026 18:58:09 -0400

Stage 2, Send: a collector moves your spans

Your instrumented application doesn’t write straight to storage. The spans first pass through a piece of software that receives them and forwards them on to a backend. That piece is a collector.

Grafana’s collector is Grafana Alloy. Alloy receives the spans your application emits and forwards them to a tracing backend. It speaks OTLP (OpenTelemetry Protocol), the standard format for sending telemetry data.

Traces add up fast

Tracing produces a higher volume of data than metrics. A single request can create dozens or hundreds of spans, and that volume grows with your traffic, so traces are one of the easiest signals to over-ingest. To keep the volume, and the cost, manageable, you keep a representative subset of traces instead of all of them, a practice called sampling. Choosing a sampling strategy is part of setup, covered in the setup journey.

Stage 3, Store: where traces live

Tue, 04 Aug 2026 18:58:09 -0400

Stage 3, Store: where traces live

Once the collector forwards your spans, they need a home. In Grafana Cloud, that backend is Grafana Cloud Traces: the managed service that stores your traces and lets you query them. It’s powered by Grafana Tempo, the open-source tracing backend Grafana Labs builds. Cloud Traces and Tempo are the same engine: one run for you, one you run yourself.

Cheap storage, no heavy index

Cloud Traces stores your traces in object storage: low-cost cloud storage for large amounts of data. Grafana Cloud manages that storage for you, so there’s nothing for you to size or provision. Cloud Traces queries those traces directly, without first building a separate index of them. Skipping that extra index is what keeps storing a large volume of traces economical.

Cloud Traces both writes traces to object storage and reads them back from it directly:

Run it for you, or run it yourself

You have two ways to use the same engine:

Grafana Cloud Traces: fully managed for you as part of Grafana Cloud. This is what you’ll use in this journey.
Grafana Tempo: the open-source backend you run and operate yourself, pointing it at object storage you provide, such as Amazon S3 or Google Cloud Storage.

The difference is who operates it, not how tracing works. Everything you learn about reading traces applies to both.

Resources

Tue, 04 Aug 2026 18:58:09 -0400

Resources

You followed a trace through the four-stage pipeline: instrument, send, store, and query. These docs go deeper on each stage when you’re ready to set one up.

Documentation

Instrument your applications: Produce spans from your application with OpenTelemetry.
OpenTelemetry documentation: The open, vendor-neutral standard most teams use to instrument applications.
Send traces to Grafana Cloud: Move spans to a backend with a collector such as Grafana Alloy.
Adaptive Traces: Control trace volume and cost by automatically keeping your most valuable traces.
Grafana Cloud Traces: The managed backend that stores and queries your traces.
Grafana Tempo: The open-source tracing backend you can run yourself.