---
title: "Trace-ID vs span-ID, ontleed in een echte traceparent-header"
description: "Een trace-ID noemt 1 request in elke service die het bereikt, en blijft gelijk. Een span-ID noemt 1 stap, dus elke service maakt een nieuwe."
canonical: "https://logbrew.co/nl/guides/trace-id"
last_updated: "2026-11-21"
---

# Trace-ID vs span-ID, ontleed in een echte traceparent-header

Een trace-ID noemt 1 request in elke service die het bereikt, en blijft gelijk. Een span-ID noemt 1 stap, dus elke service maakt een nieuwe.

Getest op 21 november 2026 met Node.js 22.18.0, @logbrew/node 0.1.30, Python 3.13.9, FastAPI 0.165.0, uvicorn 0.54.0, logbrew-fastapi 0.1.14, curl 8.7.1 en logbrew CLI 0.1.96

Door [Furkan Erday](https://github.com/furkanerday). Furkan Erday is de oprichter van LogBrew. Hij bouwt LogBrew elke dag met Claude Code en Codex.

Canonical: https://logbrew.co/nl/guides/trace-id

## Wat elke traceparent-header met de trace deed

| Header die curl stuurde | Trace-ID bleef gelijk | Beide logs delen 1 trace-ID |
| --- | --- | --- |
| Geldig, flags `01` | Ja | Ja |
| Geldig, flags `00` | Ja | Ja |
| Trace-ID in hoofdletters | Ja, in kleine letters | Ja |
| Trace-ID met alleen nullen | Nieuwe trace | Ja |
| Versie `ff` | Nieuwe trace | Ja |
| Geen header | Nieuwe trace | Ja |

6 requests naar een Node.js-service die een FastAPI-service aanroept, met @logbrew/node 0.1.30 en logbrew-fastapi 0.1.14.

## De traceparent-header ontleden

### Splits de header bij de streepjes

`traceparent` heeft 4 velden in hex met kleine letters, gescheiden door `-`. Dat zijn de versie, de trace-ID, de parent-ID en de traceflags. Dit is de header die curl naar onze service `checkout` stuurde.

Uitvoer

```text
checkout got traceparent: 00-9095c7b7bf222836f82c2c415bc2bd65-fe8e70882fecdf07-01
```

### Lees de versie

`00` is de enige versie in de W3C-aanbeveling Trace Context, en `ff` is ongeldig. Toen we `ff` stuurden, negeerden beide SDK's de header en startten ze een nieuwe trace.

### Lees de trace-ID

De volgende 32 tekens zijn de trace-ID `9095c7b7bf222836f82c2c415bc2bd65`, 16 bytes in hex. Die noemt de hele request, en elke service geeft hem ongewijzigd door. Een trace-ID met alleen nullen is ongeldig.

### Lees de parent-ID

De volgende 16 tekens zijn de parent-ID `fe8e70882fecdf07`, 8 bytes in hex. Dat is de span-ID van de aanroeper, dus hij verandert bij elke hop. Een parent-ID met alleen nullen is ongeldig.

### Lees de traceflags

De laatste 2 tekens zijn de flags, en alleen bit 0 heeft een betekenis. `01` zegt dat de aanroeper de trace kan hebben vastgelegd, en `00` dat hij dat niet deed. Ook met `00` stuurden beide SDK's hun spans, en LogBrew toonde de trace.

## De trace van Node.js naar Python doorgeven

### Installeer de 2 SDK's

Onze service `checkout` draait op Node.js met `@logbrew/node`. Hij roept `payments` aan, een FastAPI-app met `logbrew-fastapi`. Gebruik in beide een serversleutel van je LogBrew-project.

```bash
npm install @logbrew/sdk @logbrew/node
python3 -m pip install logbrew-sdk logbrew-fastapi
```

### Wikkel de Node.js-server en zijn aanroep in

`withLogBrewHttpHandler()` leest `traceparent` uit elke request en start een span. `fetchWithLogBrewSpan()` start een child-span voor de aanroep en schrijft een nieuwe `traceparent` met de ID van die span. De wrapper leest de sleutel uit `LOGBREW_SERVER_API_KEY`.

```bash
import { createServer } from "node:http";
import { fetchWithLogBrewSpan, withLogBrewHttpHandler } from "@logbrew/node";

const server = createServer(withLogBrewHttpHandler(async (req, res, logbrew) => {
  logbrew.client.log(`evt_checkout_${Date.now()}`, new Date().toISOString(), {
    message: "checkout started for order 1042",
    level: "info",
    logger: "checkout"
  });
  const reply = await fetchWithLogBrewSpan("http://127.0.0.1:28702/payments/1042", {
    method: "POST"
  }, {
    client: logbrew.client,
    trace: logbrew.trace,
    routeTemplate: "/payments/:orderId"
  });
  res.writeHead(reply.status, { "content-type": "application/json" });
  res.end(await reply.text());
}));

server.listen(28701, "127.0.0.1");
```

### Voeg LogBrew toe aan de FastAPI-app

`init_logbrew()` leest `traceparent` uit elke request en start een child-span. `logbrew.logging_handler` voegt de trace-ID en de span-ID van het request toe aan elk logrecord.

```bash
import logging
import os

from fastapi import FastAPI
from logbrew_fastapi import init_logbrew

app = FastAPI()
logbrew = init_logbrew(
    app, api_key=os.environ["LOGBREW_SERVER_API_KEY"], service_name="payments"
)
logger = logging.getLogger("payments")
logger.setLevel(logging.INFO)
logger.addHandler(logbrew.logging_handler)


@app.post("/payments/{order_id}")
def authorize(order_id: str):
    logger.warning("card declined for order %s", order_id)
    return {"orderId": order_id, "status": "declined"}
```

## De trace van een logregel vinden

### Stuur 1 request door beide services

curl stuurde een `traceparent`, zoals een browser of een gateway voor `checkout` dat kan doen. Zonder de header start `checkout` een nieuwe trace.

```bash
curl -X POST http://127.0.0.1:28701/checkout \
  -H 'traceparent: 00-9095c7b7bf222836f82c2c415bc2bd65-fe8e70882fecdf07-01'
```

Uitvoer

```text
{"orderId":"1042","status":"declined"}
```

### Vergelijk de header bij elke hop

We printten de header in elke service. `checkout` hield de trace-ID en zette de ID van zijn aanroep-span, `1a95bcb4e3fcb3ce`, in de parent-ID. `payments` las die header en startte daaronder de span `bc7e3f490d4a4d00`.

Uitvoer

```text
checkout got traceparent: 00-9095c7b7bf222836f82c2c415bc2bd65-fe8e70882fecdf07-01
checkout sent traceparent: 00-9095c7b7bf222836f82c2c415bc2bd65-1a95bcb4e3fcb3ce-01
payments got traceparent: 00-9095c7b7bf222836f82c2c415bc2bd65-1a95bcb4e3fcb3ce-01
```

### Vind elke log van de trace

Kopieer de trace-ID uit een willekeurige logregel en geef hem aan `--trace`. De CLI gaf de log van elke service terug. Plak in het dashboard de trace-ID in het zoekveld van Logs.

```bash
logbrew read logs --project "<project_id>" --trace 9095c7b7bf222836f82c2c415bc2bd65
```

Uitvoer

```text
Logs (2)
- warning card declined for order 1042 service=payments trace=9095c7b7bf222836f82c2c415bc2bd65 [unversioned / production]
- info checkout started for order 1042 service=checkout trace=9095c7b7bf222836f82c2c415bc2bd65 [unversioned / production]
```

### Open de trace

De trace heeft 3 spans, 2 van `checkout` en 1 van `payments`. Plak in het dashboard de trace-ID in het zoekveld van Verkennen en open dan de trace.

```bash
logbrew read trace 9095c7b7bf222836f82c2c415bc2bd65 --project "<project_id>"
```

Uitvoer

```text
Trace 9095c7b7bf222836f82c2c415bc2bd65 spans=3 [unversioned / production]
- POST /payments/{order_id}
- POST /payments/:orderId
- POST /checkout
```

## Wat we zagen toen we het testten

We draaiden `checkout` op Node.js 22.18 met @logbrew/node 0.1.30, en `payments` op Python 3.13.9 met FastAPI 0.165.0, uvicorn 0.54.0 en logbrew-fastapi 0.1.14. Beide stuurden naar een lokale LogBrew-server. curl stuurde 6 requests naar `checkout`, 5 met elk een andere `traceparent` en 1 zonder.

Bij elke request deelden de logs van beide services 1 trace-ID. Was de header geldig, dan was dat de trace-ID die curl stuurde. Was de header ongeldig of ontbrak hij, dan startte `checkout` een nieuwe trace en gaf die door.

|  | `span_id` | `parent_span_id` |
| --- | --- | --- |
| Request naar `checkout` | `5569d78d6d163d95` | `fe8e70882fecdf07` |
| Aanroep van `checkout` naar `payments` | `1a95bcb4e3fcb3ce` | `5569d78d6d163d95` |
| Request naar `payments` | `bc7e3f490d4a4d00` | `1a95bcb4e3fcb3ce` |

- `checkout`
  - `level`: `info`
  - Melding: `checkout started for order 1042`
  - `trace_id`: `9095c7b7bf222836f82c2c415bc2bd65`
  - `span_id`: `5569d78d6d163d95`
- `payments`
  - `level`: `warning`
  - Melding: `card declined for order 1042`
  - `trace_id`: `9095c7b7bf222836f82c2c415bc2bd65`
  - `span_id`: `bc7e3f490d4a4d00`

## Trace-ID vs span-ID

Een trace-ID is 16 bytes, geschreven als 32 hextekens. Een span-ID is 8 bytes, geschreven als 16. De OpenTelemetry-specificatie van de trace-API noemt een ID alleen geldig als minstens 1 byte niet nul is, en schrijft beide in hex met kleine letters.

In OpenTelemetry bevat een spancontext de trace-ID, de span-ID, de traceflags en de tracestatus. `traceparent` draagt de eerste 3. De header `tracestate` draagt de tracestatus, een lijst van maximaal 32 items van leveranciers. Geen van beide LogBrew-SDK's schrijft `tracestate`.

|  | Trace-ID | Span-ID |
| --- | --- | --- |
| Hextekens | `32` | `16` |
| Gelijk bij elke hop | Ja | Nee |
| Geldig met alleen nullen | Nee | Nee |

## Als de header fout is

De aanbeveling staat alleen hex met kleine letters toe, en verbiedt versie `ff` en ID's met alleen nullen. Een service die zo'n header krijgt, moet hem negeren en een nieuwe trace starten. Beide SDK's deden dat bij `ff` en bij een trace-ID of parent-ID met alleen nullen.

Beide SDK's accepteerden een trace-ID in hoofdletters en gaven hem door in kleine letters. Stuur kleine letters, want een strikte service start in plaats daarvan een nieuwe trace.

Zonder header startte `checkout` een trace met de flags `01`, en `payments` een met `00`. LogBrew bewaarde beide traces.

| Trace-ID bleef gelijk | `@logbrew/node` | `logbrew-fastapi` |
| --- | --- | --- |
| Trace-ID in hoofdletters | Ja | Ja |
| Versie `ff` | Nee | Nee |
| Trace-ID met alleen nullen | Nee | Nee |
| Parent-ID met alleen nullen | Nee | Nee |

## Veelgestelde vragen

### Wat is een trace-ID?

Een trace-ID is een ID van 16 bytes, geschreven als 32 hextekens in kleine letters. Hij noemt 1 request in elke service die het request bereikt. Elke service geeft hem door in de header `traceparent`.

### Wat is het verschil tussen een trace-ID en een span-ID?

De trace-ID is in elke service van 1 request gelijk. Een span-ID noemt 1 stap in 1 service. Onze request kreeg 1 trace-ID en 3 span-ID's.

### Wat is de traceparent-header?

`traceparent` is de HTTP-header van de W3C-aanbeveling Trace Context. Hij bevat de versie, de trace-ID, de span-ID van de aanroeper en de traceflags, zoals in `00-9095c7b7bf222836f82c2c415bc2bd65-1a95bcb4e3fcb3ce-01`.

### Wat betekent 01 aan het eind van traceparent?

`01` zet de sampled-flag, dus de aanroeper kan de trace hebben vastgelegd. `00` zegt dat hij dat niet deed. Beide LogBrew-SDK's gaven elke waarde door, en LogBrew bewaarde de trace.

### Hoe vind ik alle logs met dezelfde trace-ID?

Voer `logbrew read logs --project "<project_id>" --trace <trace_id>` uit, of plak de trace-ID in het zoekveld van Logs in het LogBrew-dashboard. Elke log die de SDK's tijdens een request schrijven, heeft de trace-ID van die request.

### Is de traceparent-header hoofdlettergevoelig?

Ja. De aanbeveling staat alleen hex met kleine letters toe. Beide LogBrew-SDK's accepteerden een trace-ID in hoofdletters en maakten hem klein, maar een strikte service negeert de header.

## Vind elke log van een trace met 1 zoekopdracht

De LogBrew-SDK's voor Node.js en FastAPI lezen en sturen `traceparent`, en elke log houdt de trace-ID van zijn request. Begin met het ruime gratis abonnement, zonder creditcard.

[Gratis beginnen](https://logbrew.co/nl)

## Bronnen

- [W3C Recommendation, Trace Context, 3.2 Traceparent Header](https://www.w3.org/TR/trace-context/#traceparent-header)
- [W3C Recommendation, Trace Context, 4.3 A traceparent is received](https://www.w3.org/TR/trace-context/#a-traceparent-is-received)
- [@logbrew/node on npm](https://www.npmjs.com/package/@logbrew/node)
- [LogBrewCo/sdk, logbrew-fastapi README](https://github.com/LogBrewCo/sdk/blob/main/python/logbrew_fastapi/README.md)

## Meer handleidingen voor agents, Python, Node.js en React

- [Een MCP-server toevoegen aan Claude Code en Codex](https://logbrew.co/nl/guides/mcp-server-claude-code-codex)
- [AGENTS.md gebruiken in Claude Code en Codex](https://logbrew.co/nl/guides/agents-md)
- [Claude overloaded error 529 en rate limit error 429 oplossen](https://logbrew.co/nl/guides/claude-overloaded-rate-limit-error)
- [Python-logging instellen met de juiste logniveaus en exceptions met traceback](https://logbrew.co/nl/guides/python-logging)
- [Structured logging met een logformaat en logniveaus die je per veld doorzoekt](https://logbrew.co/nl/guides/structured-logging)
- [Node.js-logging instellen met Pino of Winston zonder één fout te missen](https://logbrew.co/nl/guides/node-logging)
- [Stel Django-logging in en bewaar de stacktrace van elke 500-fout](https://logbrew.co/nl/guides/django-logging)
- [Stel FastAPI-logging in en handel fouten af zonder de stacktrace te verliezen](https://logbrew.co/nl/guides/fastapi-logging)
- [Voeg een React error boundary toe en log de fouten die hij mist](https://logbrew.co/nl/guides/react-error-boundary)
- [Handleidingen voor fouten, logs, traces, metrics en releases](https://logbrew.co/nl/guides)
