Décodeur traceparent — W3C Trace Context
Fini de compter les chiffres hex. Décodeur traceparent en ligne, gratuit — tout reste dans le navigateur. Trace ID, span ID, 8 bits trace-flags, tracestate, Datadog/X-Ray/B3.
- Version
00- Trace ID
4bf92f3577b34da6a3ce929d0e0e4736- Parent ID (span ID)
00f067aa0ba902b7- Trace flags
01
| Bit | Masque | Nom | État |
|---|---|---|---|
| 0 | 0x01 | sampled | 1 |
| 1 | 0x02 | random-trace-id | 0 |
| 2 | 0x04 | reserved | 0 |
| 3 | 0x08 | reserved | 0 |
| 4 | 0x10 | reserved | 0 |
| 5 | 0x20 | reserved | 0 |
| 6 | 0x40 | reserved | 0 |
| 7 | 0x80 | reserved | 0 |
Lisez ces bits avec un ET binaire. Comparer l'octet entier à 01 signale à tort toute trace qui porte en plus un bit réservé.
- x-datadog-trace-id
11803532876627986230- x-datadog-tags: _dd.p.tid
4bf92f3577b34da6- x-datadog-parent-id
67667974448284343- AWS X-Ray trace ID
1-4bf92f35-77b34da6a3ce929d0e0e4736- b3 (single header)
4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-1- X-B3-TraceId
4bf92f3577b34da6a3ce929d0e0e4736- X-B3-SpanId
00f067aa0ba902b7- X-B3-Sampled
1
Datadog transporte les 64 bits de poids faible du trace ID sous forme de chaîne décimale et les 64 bits de poids fort en hexadécimal dans un tag. Passer la valeur complète de 128 bits en décimal est la raison classique pour laquelle un trace ID venu de vos logs ne trouve rien dans l'interface.
Un identifiant X-Ray embarque un horodatage sur 32 bits ; un trace ID W3C ne porte aucun horodatage. La date ci-dessous n'a de sens que si l'identifiant provient réellement de X-Ray.
| # | Clé | Valeur | Statut |
|---|---|---|---|
| 1 | rojo | 00f067aa0ba902b7 | OK |
| 2 | congo | t61rcWkgMzE | OK |
Format traceparent : anatomie des champs
| Champ | Chiffres hex | Octets | Signification | Valeur invalide |
|---|---|---|---|---|
| version | 2 | 1 | Version du format. Toujours 00 aujourd'hui ; ff est interdit. | ff |
| trace-id | 32 | 16 | Identifie la trace entière, de bout en bout. | Tout à zéro |
| parent-id | 16 | 8 | Identifie le span appelant, pas la requête. | Tout à zéro |
| trace-flags | 2 | 1 | Un champ de 8 bits — lisez-le bit par bit, jamais comme un booléen. | — |
Valeurs de trace-flags : 00, 01, 02 et 03 expliquées
| Hex | Binaire | sampled | random-trace-id | Signification |
|---|---|---|---|---|
| 00 | 00000000 | 0 | 0 | L'amont a choisi de ne pas échantillonner — regardez du côté de l'appelant, pas de votre service. |
| 01 | 00000001 | 1 | 0 | Enregistrée normalement. C'est ce que vous voyez la plupart du temps. |
| 02 | 00000010 | 0 | 1 | Trace ID aléatoire déclaré, mais pas d'échantillonnage. |
| 03 | 00000011 | 1 | 1 | Enregistrée, et le trace ID est déclaré uniformément aléatoire. |
bit 0 — L'appelant a enregistré cette trace. À zéro, il a délibérément choisi de ne pas le faire.
bit 1 — Level 2 : les 7 octets de droite du trace ID sont uniformément aléatoires.
bit 2-7 — Réservé. Doit être ignoré à la réception et remis à zéro sur les requêtes sortantes.
Construit directement d'après la recommandation W3C Trace Context et la candidate recommendation Level 2, avec un analyseur couvert par des tests unitaires pour chaque forme valide et invalide que nomme la spécification.
Qu'est-ce que l'en-tête traceparent ?
traceparent est l'en-tête HTTP qui transporte une trace distribuée d'un service au suivant. Avant sa normalisation, chaque fournisseur de traçage propageait le contexte dans son propre en-tête, si bien qu'une requête traversant plusieurs systèmes perdait son identité à la frontière. La spécification W3C Trace Context a réglé cela avec un format unique, délibérément minimal : version-trace-id-parent-id-trace-flags, quatre champs hexadécimaux joints par des tirets, 55 caractères au total pour la version actuelle.
Chaque champ a un seul rôle. La version vaut toujours 00 aujourd'hui, et ff est purement interdit. Le trace-id tient sur 16 octets et identifie la requête entière de bout en bout — il reste constant à chaque saut. Le parent-id tient sur 8 octets et identifie le span de l'appelant immédiat : contrairement au trace-id, il change donc à chaque saut. C'est dans l'octet trace-flags que se loge l'essentiel de la confusion : il ressemble à un booléen parce que 01 est de loin la valeur la plus courante, mais ce sont huit bits. Le bit 0 est sampled. Le bit 1, ajouté par Trace Context Level 2, est random-trace-id : il affirme que les sept octets de droite du trace ID sont uniformément aléatoires, autorisant les systèmes en aval à échantillonner ou répartir dessus. Les six bits restants sont réservés, et c'est exactement pour cela que le champ doit être lu avec un ET binaire plutôt que comparé pour égalité.
Un en-tête compagnon, tracestate, transporte à côté des paires clé-valeur propres aux fournisseurs, plafonnées à 32 membres. Ce plafond explique un symptôme déroutant : des données de fournisseur présentes en périphérie et disparues quelques sauts plus loin, parce que les intermédiaires ont commencé à supprimer des entrées dès que la liste a dépassé la limite. L'en-tête est devenu véritablement universel quand OpenTelemetry l'a adopté, et cette page décode l'ensemble — champs, bits, membres tracestate et identifiants équivalents des autres formats de propagation — sans rien envoyer nulle part.
# The header as it travels on the wire
traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE
# Read the four fields apart
# version 00
# trace-id 4bf92f3577b34da6a3ce929d0e0e4736 (16 bytes, whole request)
# parent-id 00f067aa0ba902b7 (8 bytes, calling span)
# trace-flags 01 (bit 0 set = sampled)
# Send one yourself
$ curl -H 'traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01' \
https://example.com/api Fonctionnalités clés
Chaque champ isolé et copiable
Version, trace-id, parent-id et trace-flags obtiennent chacun leur ligne et leur bouton de copie : extraire un trace ID de 32 caractères vers une requête prend un clic au lieu d'une sélection minutieuse.
trace-flags lu comme huit bits
L'octet de drapeaux est déplié sur ses huit positions avec leurs masques hexadécimaux. Le bit 0 est sampled, le bit 1 est le drapeau random-trace-id du Level 2, et les bits réservés sont affichés plutôt que silencieusement écartés.
Conversion vers Datadog, X-Ray et B3
Les 64 bits de poids faible en trace ID Datadog décimal, les 64 bits de poids fort en tag associé, la forme X-Ray 1-{8}-{24}, et les deux dispositions B3, en-tête unique et multiples — le tout calculé avec BigInt pour qu'aucune valeur ne déborde.
Des diagnostics, pas seulement des verdicts
Un trace ID entièrement à zéro est expliqué comme un traçage jamais initialisé ; un bit sampled à zéro, comme une décision prise en amont. Savoir dans lequel des deux cas vous êtes constitue souvent toute la session de débogage.
tracestate et son plafond de 32 membres
Les membres sont listés avec une validation de la clé et de la valeur pour chacun, et un décompte permanent face à la limite de la spécification — la limite qui explique pourquoi les données d'un fournisseur s'évaporent quelques sauts plus loin.
Rien ne quitte votre navigateur
L'analyse repose sur de simples opérations de chaînes et BigInt, sans dépendance ni appel réseau, vérifiée par un test de contrat automatisé à chaque build. « Copier le lien » utilise le fragment d'URL, qui n'est jamais transmis.
Exemples de traceparent, décodés
L'exemple de la spécification, décodé
00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
version 00 · trace-id 4bf92f3577b34da6a3ce929d0e0e4736 · parent-id 00f067aa0ba902b7 · trace-flags 01 (sampled)
Quatre champs séparés par des tirets, 55 caractères au total pour la version 00. Le trace-id identifie la requête entière à travers tous les services ; le parent-id — souvent appelé span ID — n'identifie que l'appelant immédiat, ce qui explique qu'il change à chaque saut alors que le trace-id reste identique. Le 01 final est un octet complet, pas un booléen : le bit 0 est à 1, donc l'appelant a enregistré cette trace.
trace-flags 00 — l'appelant a choisi de ne pas enregistrer
00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00
En-tête valide · bit sampled à zéro
Cet en-tête est parfaitement valide, et c'est tout le sujet. Un bit sampled à zéro est une consigne venue de l'amont, pas un défaut de votre service : celui qui vous a appelé a évalué son échantillonneur et a choisi de ne pas enregistrer. Chercher ici des spans manquants dans votre propre configuration coûte des heures. La bonne question est de savoir quel service vous appelle, transmet un span parent et décide de ne pas échantillonner la trace.
Un trace-id entièrement à zéro signifie que le traçage n'a jamais démarré
00-00000000000000000000000000000000-00f067aa0ba902b7-01
Invalide — trace-id entièrement à zéro
La spécification déclare invalide un trace-id entièrement à zéro et exige que le traceparent soit ignoré dans son ensemble. Il vaut la peine de savoir ce qu'il signale en pratique : non pas « une trace qui n'a pas encore de données », mais un SDK qui n'a jamais été initialisé, ou un middleware qui injecte un en-tête bouche-trou. La même règle s'applique à un parent-id entièrement à zéro.
Le même trace ID au format Datadog
00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
x-datadog-trace-id 11803532876627986230 · _dd.p.tid 4bf92f3577b34da6
Datadog transporte les 64 bits de poids faible d'un trace ID de 128 bits sous forme de chaîne décimale, et les 64 bits de poids fort en hexadécimal dans un tag distinct. Passez la valeur complète de 128 bits en décimal et vous obtenez un nombre qui ne correspond à rien — c'est précisément pour cela que cette conversion revient sans cesse dans les gestionnaires de tickets des tracers. La moitié basse vaut ici a3ce929d0e0e4736, et 64 bits dépassent ce qu'un nombre JavaScript peut contenir : cette page fait donc le calcul avec BigInt.
Comment utiliser le décodeur traceparent
- 1
Collez l'en-tête traceparent
Déposez la valeur brute de l'en-tête — par exemple 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01. Le décodage se fait à la frappe ; il n'y a aucun bouton à presser.
- 2
Lisez les quatre champs séparément
Version, trace-id, parent-id et trace-flags sont répartis sur leurs propres lignes, chacune avec un bouton de copie, pour extraire le seul trace ID vers une requête sans sélectionner 32 caractères à la main.
- 3
Vérifiez les drapeaux bit par bit
L'octet trace-flags est déplié en ses huit bits avec leurs masques, si bien que sampled et le drapeau random-trace-id du Level 2 sont visibles séparément au lieu d'être cachés dans une valeur de deux caractères.
- 4
Convertissez vers le format de votre backend
Datadog, AWS X-Ray et les deux formes de B3 sont générés en dessous, y compris le trace ID décimal sur 64 bits de poids faible qu'attend Datadog et le tag de poids fort qui l'accompagne.
- 5
Ajoutez tracestate et partagez le résultat
Collez un en-tête tracestate pour lister ses membres avec une validation individuelle et un décompte face à la limite de 32, puis utilisez « Copier le lien » pour figer l'état exact dans une URL à déposer dans un ticket.
Erreurs fréquentes avec traceparent
Comparer l'octet de drapeaux entier à 01
Cela traite un champ de huit bits comme une énumération. Une trace échantillonnée qui porte aussi le drapeau random-trace-id du Level 2 a des flags à 03, et le test d'égalité la déclare non échantillonnée.
if (traceFlags === 0x01) { record(); } if (traceFlags & 0x01) { record(); } Convertir les 128 bits en un seul nombre décimal
Datadog attend les 64 bits de poids faible en décimal et les 64 bits de poids fort en hexadécimal dans un tag distinct. Passer la valeur complète en un seul nombre décimal produit un identifiant qui ne correspond à rien.
x-datadog-trace-id: 100985939111033328018442752961257817910
x-datadog-trace-id: 11803532876627986230 x-datadog-tags: _dd.p.tid=4bf92f3577b34da6
Rejeter toute version différente de 00
La spécification demande aux analyseurs de lire ce qu'ils reconnaissent d'une version supérieure et de tolérer les champs en trop. Rejeter d'emblée redémarre la trace et rompt le lien à la frontière.
if (version !== '00') throw new Error('bad traceparent'); if (version !== '00' && header.length >= 55) { /* parse the known prefix */ } Émettre de l'hexadécimal en majuscules
La grammaire n'admet que les minuscules. Un trace ID en majuscules porte la bonne valeur et se fait quand même rejeter par un destinataire conforme, ce qui en fait un bug particulièrement pénible à repérer à l'œil nu.
traceparent: 00-4BF92F3577B34DA6A3CE929D0E0E4736-00F067AA0BA902B7-01
traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
Ce que vous pouvez faire avec le décodeur traceparent
- Comprendre pourquoi une trace n'a aucun span
- Collez l'en-tête entrant et lisez le bit sampled. S'il est à zéro, la trace n'allait jamais être enregistrée et la réponse est chez l'appelant, pas dans votre instrumentation — une distinction qui économise beaucoup de temps passé à auditer votre propre échantillonneur.
- Retrouver une trace que votre backend ne trouve pas
- Quand un trace ID copié depuis les logs applicatifs ne donne rien dans Datadog, le format est presque toujours en cause. Convertissez-le ici pour obtenir l'identifiant décimal sur 64 bits de poids faible attendu par l'API, ainsi que le tag de poids fort qui doit l'accompagner.
- Vérifier les en-têtes injectés par votre passerelle
- Les proxys et les service meshes génèrent le contexte de trace à l'entrée. Collez ce qui est réellement arrivé pour confirmer la longueur, l'hexadécimal en minuscules et des identifiants non nuls avant de supposer que la panne est en aval.
- Rejouer une trace de production à la main
- Reprenez un en-tête d'une vraie requête et rejouez-le contre un point d'entrée de préproduction pour suivre la même trace. Construisez la requête avec le générateur de commandes curl et collez-y l'en-tête directement.
- Expliquer Trace Context à une équipe
- Les tableaux d'anatomie des champs et des trace-flags de cette page sont un support de référence statique que vous pouvez montrer, et les puces d'exemple démontrent chaque cas d'erreur sans que personne ait à casser un service pour en produire un.
Comment fonctionne le validateur W3C Trace Context
- La grammaire des quatre champs
- version "-" trace-id "-" parent-id "-" trace-flags, entièrement en hexadécimal minuscule. Version fait 2 chiffres, trace-id 32, parent-id 16 et trace-flags 2 — soit 52 chiffres hexadécimaux plus 3 tirets, exactement 55 caractères pour la version 00. L'hexadécimal en majuscules rend l'en-tête invalide même si la valeur paraît correcte, et un trace-id comme un parent-id entièrement à zéro sont explicitement invalides plutôt que vides.
- trace-flags est un champ de bits
- Le bit 0 (masque 0x01) est sampled : à 1, il signifie que l'appelant a peut-être enregistré des données de trace. Le bit 1 (masque 0x02), introduit au Level 2, est random-trace-id : à 1, au moins les 7 octets de droite du trace-id doivent avoir été tirés au hasard selon une distribution uniforme, ce qui permet aux systèmes en aval d'échantillonner ou de répartir dessus. Les bits 2 à 7 sont réservés et doivent être ignorés à la réception et remis à zéro sur les requêtes sortantes. Comme des bits réservés peuvent être présents, le champ doit être testé avec un ET binaire — un test d'égalité contre 0x01 signale à tort une trace échantillonnée qui porte aussi un bit réservé.
- Compatibilité ascendante avec les versions futures
- La version vaut 00 aujourd'hui et ff est interdit, mais un analyseur qui rejette tout le reste a tort. La spécification demande aux destinataires de tenter l'analyse lorsque la version est supérieure et que l'en-tête est au moins aussi long que le format connu : lire les champs reconnus et tolérer les données supplémentaires en fin de chaîne, plutôt que de redémarrer la trace. Ce décodeur suit cette règle : une version future est analysée correctement et signalée comme avertissement et non comme erreur.
- Les limites de tracestate qui mordent en production
- Au plus 32 membres de liste — c'est une borne syntaxique stricte : au-delà, l'en-tête est invalide et les destinataires le rejettent. Chaque clé fait au plus 256 caractères et commence par une lettre minuscule ou un chiffre ; depuis Level 2, le @ est un caractère de clé ordinaire et non plus un séparateur de tenant. Chaque valeur compte de 1 à 256 caractères ASCII imprimables, sans jamais de virgule ni de signe égal. Les clés en double sont invalides, mais les membres de liste vides sont explicitement autorisés — la virgule laissée en fin de liste par un intermédiaire qui a supprimé une entrée donne encore un en-tête valide. Point distinct : les fournisseurs devraient propager au moins 512 caractères de l'en-tête combiné ; lorsqu'ils doivent élaguer pour tenir dans ce budget, les entrées de plus de 128 caractères partent en premier — voilà pourquoi les données d'un fournisseur bavard disparaissent avant celles d'un fournisseur concis.
Bonnes pratiques Trace Context
- Testez les drapeaux avec un ET binaire
- Écrivez flags & 0x01 plutôt que flags == 0x01. Six des huit bits sont réservés à un usage futur, et un test d'égalité se mettra à mal signaler les traces échantillonnées dès que l'un d'eux apparaîtra dans la nature.
- Traitez un identifiant tout à zéro comme un pipeline cassé
- Ce n'est pas une valeur vide à tolérer. Rejetez l'en-tête, et allez trouver le composant qui n'a pas initialisé son tracer ou qui injecte un bouche-trou.
- Regardez en amont quand le bit sampled est à zéro
- Les échantillonneurs parent-based propagent la décision de l'appelant. Si des traces manquent, identifiez le service qui vous envoie un span parent avec l'échantillonnage désactivé avant d'auditer votre propre configuration.
- Gardez tracestate court
- Le plafond de 32 membres est une borne syntaxique stricte — le dépasser rend l'en-tête invalide. Point distinct : seuls 512 caractères de l'en-tête combiné sont garantis en propagation, et l'élagage supprime d'abord les entrées de plus de 128 caractères. Tout ce qui doit survivre à une longue chaîne d'appels n'a pas sa place dans tracestate.
- Ne journalisez jamais un trace ID comme nombre JavaScript
- Un trace ID de 128 bits, et même un identifiant Datadog de 64 bits, dépassent tous deux Number.MAX_SAFE_INTEGER. Gardez-les sous forme de chaînes et convertissez avec BigInt quand un calcul s'impose, sinon vous corromprez silencieusement les derniers chiffres.
FAQ du décodeur traceparent
Qu'est-ce que l'en-tête traceparent ?
Que signifie traceparent trace-flags 00 ?
Quelle est la différence entre trace-flags 01, 02 et 03 ?
Pourquoi mon trace ID est-il entièrement à zéro ?
Comment convertir un trace ID W3C en trace ID Datadog ?
Un traceparent contient-il un horodatage ?
L'en-tête que je colle ici est-il envoyé quelque part ?
Ce décodeur fonctionne-t-il hors ligne ?
Outils connexes
Voir tous les outils →Générateur & Constructeur de commande cURL
Web & API
Construisez des commandes curl dans votre navigateur — méthode, en-têtes, authentification et corps, obtenez instantanément une commande prête à copier. Préréglages Bearer, POST JSON, upload. Gratuit, privé, sans inscription.
Générateur htpasswd — bcrypt, Apache MD5 (apr1), Basic Auth
Web & API
Générez des entrées htpasswd avec bcrypt, Apache MD5 (apr1), SHA-1 et plus. Obtenez des configs Apache, nginx et Docker prêtes à coller. 100 % dans votre navigateur — aucun envoi.
Générateur de balises meta & Open Graph
Web & API
Générez des balises Open Graph, Twitter Card et SEO avec un aperçu en direct pour Google, Facebook et X. 100 % gratuit, dans le navigateur, sans inscription — copiez-collez le code.
Testeur nginx location — pourquoi ce bloc l'emporte
Web & API
Quel bloc location nginx l'emporte — et pourquoi les autres ont perdu. Testeur gratuit pour =, ^~, ~ et ~*, tout dans votre navigateur.
Outil de déchiffrement AES — compatible OpenSSL et CryptoJS
Outils de sécurité
Déchiffrez de l'AES en ligne — GCM/CBC/CTR, phrase secrète ou clé brute, détection automatique du format OpenSSL et CryptoJS « U2FsdGVkX1 ». 100 % dans le navigateur, les clés ne quittent jamais la page.
Outil de chiffrement AES — GCM, CBC et CTR
Outils de sécurité
Chiffrement AES en ligne gratuit — AES-128/192/256, GCM/CBC/CTR, phrase secrète (PBKDF2) ou clé brute. 100 % dans votre navigateur ; rien n'est envoyé.