Managed Service for OpenTelemetry s'appuie sur le modèle de données OpenTracing pour offrir une traçabilité distribuée aux architectures microservices. Cette rubrique présente les traces, les spans, le modèle de données ainsi que les méthodes d'envoi des données.
OpenTracing est le prédécesseur d'OpenTelemetry. Managed Service for OpenTelemetry prend en charge le modèle de données OpenTracing décrit ici. Pour consulter la norme OpenTelemetry, reportez-vous à la documentation OpenTelemetry.
Concepts clés
| Concept | Description |
|---|---|
| Traçabilité distribuée | Méthode permettant de suivre le cheminement des requêtes à travers plusieurs services au sein d'un système distribué. |
| Trace | Enregistrement complet d'une transaction ou d'un processus dans un système distribué. Une trace constitue un graphe orienté acyclique (DAG) composé de spans. |
| Span | Unité de travail nommée et horodatée au sein d'une trace. |
| SpanContext | Métadonnées identifiant une span (ID de trace, ID de span) et transportant des éléments contextuels (baggage) à travers les limites des processus. |
| Référence | Relation de causalité entre deux spans. OpenTracing définit deux types : ChildOf et FollowsFrom. |
| Tracer | Interface permettant de créer des spans et de propager le contexte entre les services. |
Importance de la traçabilité distribuée
Les applications modernes reposent sur des architectures microservices où les développeurs adoptent des méthodologies telles que le développement agile et l'intégration continue. L'architecture système a évolué, passant de logiciels monolithiques à grande échelle vers des architectures basées sur les microservices, dans lesquelles une seule requête peut traverser des dizaines de services. Ces services peuvent être écrits dans différents langages, maintenus par différentes équipes et déployés sur plusieurs serveurs. Lorsqu'une défaillance survient dans un service, des dizaines d'applications peuvent rencontrer des exceptions, et il devient impossible d'identifier la cause racine sans une visibilité de bout en bout.
Un système de traçabilité distribuée enregistre le parcours d'exécution complet et la chronologie de chaque requête, y compris le déroulement des appels de méthode distants et leur durée. Cette visibilité est essentielle pour résoudre les problèmes système et optimiser les performances.
Traces
Une trace représente le déroulement d'une transaction ou d'un processus au sein d'un système distribué. Selon la norme OpenTracing, une trace est un graphe orienté acyclique (DAG) composé de plusieurs spans. Chaque span correspond à un segment nommé et horodaté exécuté de manière continue dans la trace.
Par exemple, une requête client peut transiter par un équilibreur de charge, un service d'authentification et un service de facturation avant d'atteindre la ressource cible et de renvoyer une réponse.
Les systèmes de traçabilité affichent généralement ces informations sous forme de chronologie, où chaque ligne représente une span et l'axe horizontal représente le temps.
Spans
Une span représente une unité de travail unique au sein d'une trace. Chaque span contient les données suivantes :
| Champ | Description |
|---|---|
| Nom de l'opération | Libellé lisible par l'humain décrivant le travail effectué (également appelé nom de la span). |
| Horodatage de début | Moment où l'opération a commencé. |
| Horodatage de fin | Moment où l'opération s'est terminée. |
| Tags | Paires clé-valeur annotant la span. Les clés sont des chaînes de caractères ; les valeurs peuvent être des chaînes, des booléens ou des nombres. |
| Journaux | Paires clé-valeur horodatées enregistrant des événements survenant pendant la durée de vie de la span. Les clés sont des chaînes de caractères ; les valeurs peuvent être de n'importe quel type. |
| SpanContext | Métadonnées permettant d'identifier la span et de la propager à travers les limites des processus. Voir SpanContext. |
| Références | Liens vers d'autres spans établissant des relations parent-enfant ou séquentielles. Peut inclure zéro ou plusieurs spans associées. |
Relations entre spans
OpenTracing définit deux types de références entre les spans :
ChildOf : Relation parent-enfant. Par exemple, la span C est un nœud enfant de la span A.
FollowsFrom : Relation séquentielle. Par exemple, la span G est appelée après la span F.
Le diagramme suivant illustre huit spans et leurs relations au sein d'une même trace :
Causal relationships among spans in a single trace
[Span A] <-- root span
|
+------+------+
| |
[Span B] [Span C] (ChildOf: Span C is a child of Span A)
| |
[Span D] +---+-------+
| |
[Span E] [Span F] >>> [Span G] >>> [Span H]
^
|
(FollowsFrom: Span G follows Span F)La même trace affichée sous forme de chronologie :
Time relationships among spans in a single trace
--|-------|-------|-------|-------|-------|-------|-------|-> time
[Span A..........................................................]
[Span B...................................................]
[Span D................................................]
[Span C...............................................]
[Span E.......] [Span F..] [Span G..] [Span H..]SpanContext
Un SpanContext transporte les métadonnées nécessaires pour identifier une span et la propager à travers les limites des processus. Il contient :
Trace ID : Identifiant unique de l'ensemble de la trace.
Span ID : Identifiant unique de la span individuelle.
Éléments de contexte (Baggage items) : Paires clé-valeur qui accompagnent la trace à travers les limites des services. Ces paires clé-valeur doivent également être transmises à travers les limites des processus.
Interface Tracer
Le Tracer constitue le point d'entrée pour créer des spans et propager le contexte entre les services. Il fournit la méthode StartSpan pour créer une span, la méthode Extract pour extraire le contexte et la méthode Inject pour injecter le contexte.
Créer une span
Utilisez la méthode StartSpan pour créer et démarrer une nouvelle span. La méthode renvoie une span avec le nom d'opération spécifié et les options choisies.
// Method signature:
// StartSpan(operationName string, opts ...StartSpanOption) Span
// Create a root span (no parent).
sp := tracer.StartSpan("GetFeed")
// Create a child span.
sp := tracer.StartSpan(
"GetFeed",
opentracing.ChildOf(parentSpan.Context()),
)Propager le contexte entre les services
Pour transmettre le contexte de trace entre les services, le Tracer propose deux méthodes complémentaires :
-
Inject : Sérialise un SpanContext (incluant l'ID de trace, l'ID de span et les éléments de contexte) dans un support (tel que les en-têtes HTTP) avant d'envoyer une requête à un autre service.
// Method signature: // Inject(sm SpanContext, format interface{}, carrier interface{}) error carrier := opentracing.HTTPHeadersCarrier(httpReq.Header) err := tracer.Inject( span.Context(), opentracing.HTTPHeaders, carrier, ) -
Extract : Désérialise un SpanContext (incluant l'ID de trace, l'ID de span et les éléments de contexte) à partir d'un support lors de la réception d'une requête provenant d'un autre service.
// Method signature: // Extract(format interface{}, carrier interface{}) (SpanContext, error) carrier := opentracing.HTTPHeadersCarrier(httpReq.Header) clientContext, err := tracer.Extract( opentracing.HTTPHeaders, carrier, )
L'utilisation conjointe des méthodes Inject et Extract permet une traçabilité de bout en bout à travers les limites des processus et du réseau.
Envoi des données
Managed Service for OpenTelemetry prend en charge deux méthodes pour envoyer les données de trace :
Envoi direct
L'application envoie les données de trace directement au backend de traçabilité, sans intermédiaire.
Envoi via un agent
L'application envoie les données de trace à un agent local (tel que Jaeger Agent), qui transfère ensuite les données au backend de traçabilité.
