Maîtriser l'analyse des traces avec Span Links à l'aide d'OpenTelemetry et Signoz (un guide pratique)

Objectif de ce didacticiel

Le but de ce didacticiel est de fournir un guide pratique et facile à comprendre sur les liens span dans OpenTelemetry.

Il vise à aider les développeurs, en particulier ceux qui travaillent avec des systèmes complexes et asynchrones, à comprendre ce que sont les liens span, en quoi ils diffèrent des relations parent-enfant traditionnelles en matière de traçage et pourquoi ils sont utiles pour une meilleure corrélation de trace.

À la fin de ce guide, vous acquerrez les compétences nécessaires pour utiliser efficacement les liens span pour suivre les interactions au sein des systèmes distribués, conduisant ainsi à une observabilité et un débogage améliorés.

Une brève introduction au traçage distribué

Dans le passé, les applications étaient généralement monolithiques, ce qui signifie que chaque processus ou fonctionnalité est exécuté comme une seule unité sur un seul serveur. La surveillance de ces applications était simple.

Par exemple : si quelque chose ne va pas, vous pouvez consulter les journaux de ce serveur pour identifier le problème. Cependant, l'essor des microservices a modifié cette simplicité.

Aujourd'hui, les applications modernes sont souvent constituées de dizaines, voire de centaines de services plus petits et indépendants qui fonctionnent ensemble. Par exemple : lorsque vous utilisez une application mobile pour passer une commande, il peut exister des services distincts pour gérer l'authentification des utilisateurs, traiter les paiements, gérer l'inventaire et envoyer des e-mails de confirmation.

Ces services ne résident pas toujours sur le même serveur et peuvent même communiquer via Internet, ce qui ajoute de la complexité au suivi de ce qui se passe lorsque vous interagissez avec une application.

C'est là qu'intervient le traçage distribué. Considérez le traçage distribué comme un moyen de suivre une requête unique lorsqu'elle transite par divers services dans une application complexe. Il suit le parcours d'une requête à travers un système complexe.

Dans les applications modernes, les requêtes transitent souvent par plusieurs services, chacun s'exécutant sur des machines différentes. Le traçage distribué nous aide à visualiser ce parcours, ce qui facilite l'identification des goulots d'étranglement et des erreurs.

C'est comme une carte de détective qui relie les points entre chaque étape du processus, vous montrant combien de temps chaque partie a pris et où les problèmes sont survenus. Lorsque vous examinez une trace, vous voyez une chronologie de la façon dont votre demande a évolué via différents services, ce qui facilite l'identification des ralentissements, des erreurs ou des échecs.

Repo de codes

Voici le dépôt de code pour ce tutoriel :
[https://github.com/Noibisjunior/Span-Links-in-OpenTelemetry]

Le rôle de l'OpenTelemetry dans l'observabilité moderne

OpenTelemetry est un acteur clé pour permettre ce type de visibilité. Il s'agit d'un cadre d'observabilité open source qui permet aux développeurs de collecter des données telles que des journaux, des métriques et des traces à partir de leurs applications. Il sert d'ensemble d'outils pour capturer des informations détaillées sur ce qui se passe au sein de vos services.

Dans le monde de l'observabilité moderne, OpenTelemetry vous aide à comprendre les performances et la santé de vos applications distribuées. Il agit comme un pont qui rassemble les données de divers services et les envoie à des outils comme SigNoz, où vous pouvez visualiser ce qui se passe. Cela rend OpenTelemetry inestimable pour identifier les goulots d'étranglement, traquer les erreurs et garantir le bon fonctionnement de vos applications.

En utilisant OpenTelemetry avec le traçage distribué, vous pouvez obtenir une image complète du comportement de vos applications, ce qui facilite le diagnostic des problèmes et améliore l'expérience utilisateur.

L'importance des travées en tant qu'éléments constitutifs du traçage dans OpenTelemetry

À mesure que les logiciels, en particulier les systèmes distribués, gagnent en complexité, comprendre leur fonctionnement interne devient une tâche difficile. C'est là que les travées d'OpenTelemetry entrent en jeu pour résoudre le défi facilement.

Que sont les portées ?

Une étendue est une unité de travail fondamentale dans le système de traçage d'OpenTelemetry. Il s'agit d'une opération ou d'un événement unique qui se produit au sein de votre application.

Il capture ce qui s'est passé au cours de cette opération, combien de temps cela a pris et tous les détails pertinents, comme si elle a réussi ou échoué.

Par exemple, imaginez que votre application traite une demande d'utilisateur :

• Lorsque la demande arrive, OpenTelemetry crée un span qui représente la demande reçue.
• Si la requête déclenche ensuite une requête de base de données, une autre étendue est créée pour représenter cette interaction avec la base de données.
• Si l'application appelle un autre service, un autre span le suit.

Attributs clés d'un span :

1. Nom : une étiquette descriptive de l'opération (par exemple, "Obtenir les données utilisateur").
2. Horodatage de début et de fin : heure de début et de fin de l'opération.
3. Parent Span : l'étendue qui a initié cette opération.
4. Balises : métadonnées supplémentaires (par exemple, code d'état HTTP, messages d'erreur).

Comment les étendues fonctionnent ensemble pour créer des traces

Individuellement, les travées sont utiles, mais elles sont efficaces lorsqu'elles travaillent ensemble pour former une trace.

Une trace est un ensemble d'étendues qui représente l'intégralité du parcours d'une requête ou d'une opération à mesure qu'elle circule dans votre système.

Reprenons notre exemple de demande utilisateur :

La trace commence lorsque la requête entre dans le système et qu'un span racine est créé. Lorsque la requête déclenche la requête de base de données, le span d'interaction avec la base de données est lié au span racine, montrant qu'il fait partie du même processus.

Des durées supplémentaires pour appeler d'autres services sont ajoutées à la trace. En examinant cette trace, vous pouvez avoir une vue d'ensemble de la manière dont la requête a parcouru différentes parties de votre système. Cela vous aide à comprendre non seulement ce qui s'est passé, mais aussi comment les différentes parties de votre application sont connectées.

Pourquoi les portées sont-elles importantes ?

1. Identification des problèmes : les spans vous aident à zoomer sur les endroits où les choses ne vont pas. Si une requête est lente, les spans peuvent vous indiquer si c'est la requête de base de données, l'appel réseau ou une autre partie du processus qui est à l'origine du retard. Vous pouvez voir quelle période a pris plus de temps que prévu, ce qui facilite la recherche des goulots d'étranglement.

2. Contexte de construction : chaque période contient des informations contextuelles telles que l'heure de début, l'heure de fin et des étiquettes personnalisées (attributs). Ces données fournissent un aperçu de ce qui se passait à un moment donné dans votre système, comme l'ID utilisateur spécifique impliqué dans une requête ou la requête qui a été exécutée.

3. Créer des relations : Les spans entretiennent des relations les uns avec les autres, souvent dans une structure parent-enfant. Le span racine est le parent et les spans suivants sont ses enfants. Cette structure vous aide à voir l'ordre dans lequel les événements se sont produits et comment ils dépendent les uns des autres. C'est comme regarder un arbre généalogique des opérations dans votre application.

4. Débogage des systèmes distribués : pour les applications avec des microservices (où différents services gèrent différentes parties d'une requête), les étendues sont particulièrement cruciales. Ils vous aident à suivre une demande lors de son déplacement entre les services, même si ces services s'exécutent sur des serveurs différents ou dans des centres de données différents. Ceci est essentiel pour comprendre les interactions complexes entre les services.

Comprendre les liens Span dans OpenTelemetry

Que sont les liens Span ?

Dans le monde des systèmes distribués, où plusieurs services travaillent ensemble pour traiter une requête utilisateur, le traçage est comme une carte de détective, il montre le chemin qu'emprunte une requête lorsqu'elle transite par ces services. Chaque activité de ce voyage s'appelle une durée, et un voyage complet s'appelle une trace.

Traditionnellement, les travées sont connectées à l'aide de relations parent-enfant. Imaginez-les comme un arbre généalogique : un span parent initie un processus (comme faire une demande à un autre service), et les spans enfants représentent les activités qui en résultent (comme le service traitant la demande). Il s’agit d’un moyen simple de représenter le flux d’une demande.

Mais que se passe-t-il lorsque deux durées sont liées, mais qu'elles ne s'intègrent pas parfaitement dans cette hiérarchie parent-enfant ? C'est là qu'interviennent les liens span.

Un lien span vous permet de connecter deux span qui sont liés mais n'ont pas de relation parent-enfant directe. C'est comme une « référence » ou un « raccourci » entre deux activités dans un système distribué.

Par exemple, disons qu'un utilisateur fait une requête qui déclenche plusieurs processus indépendants, comme l'envoi d'un e-mail et l'écriture dans une base de données. Ces processus ne sont pas des activités enfants les uns des autres ; ils se produisent côte à côte. À l'aide d'un lien span, vous pouvez indiquer que le span d'envoi d'e-mail et le span d'écriture de la base de données sont liés à la même demande initiale de l'utilisateur, même s'ils ne sont pas directement liés dans le concept parent-enfant.

En quoi les liens Span diffèrent des relations parent-enfant

Relation Parent-Enfant : c'est un enchaînement simple d'événements. Un utilisateur envoie une requête (parent), qui déclenche la création d'un enregistrement dans une base de données (enfant). Le span enfant n’existerait pas sans le span parent, ce qui en fait une conséquence directe.

Span Links : il s'agit plutôt de tracer des lignes pointillées entre des activités qui sont liées dans un certain contexte mais qui ne suivent pas une chaîne directe d'actions. Ils permettent de dire : « Ces choses sont liées, même si l’une n’a pas directement causé l’autre. » Les liens Span sont idéaux pour représenter des activités ou des événements parallèles qui interagissent mais ne sont pas strictement hiérarchiques.

Importance des liens Span dans les systèmes complexes et asynchrones

Les liens Span sont particulièrement précieux dans les systèmes complexes et asynchrones, où le flux des événements ne suit pas toujours un chemin parent-enfant clair. Voici quelques scénarios sur la façon dont il peut être utilisé dans la pratique ;

Flux de travail asynchrones :

Imaginez une demande utilisateur qui commence par un travail en arrière-plan (comme générer un rapport). La requête initiale se termine, mais la génération du rapport continue en arrière-plan.

Grâce à l'implémentation de liens span, vous pouvez relier la durée de la demande initiale à la durée de la tâche en arrière-plan, même si elles ne suivent pas un modèle parent-enfant direct.

Communication par microservices :

Dans une architecture de microservices, les services communiquent souvent entre eux de manière non strictement hiérarchique.

Par exemple, une action utilisateur peut déclencher plusieurs services pour traiter simultanément différentes parties des données. Les liens Span vous permettent de suivre ces plages indépendantes et liées dans le cadre d'un flux de travail plus large.

Traitement par lots : Si vous traitez des lots de données dans lesquels chaque élément du lot génère ses propres étendues, vous pouvez utiliser des liens d'étendue pour relier ces étendues au processus par lots d'origine.

Cela facilite le suivi de l'intégralité du cycle de vie d'un lot et la compréhension du lien entre les éléments individuels et le processus principal.

Conditions préalables : outils et bibliothèques requis pour configurer Span Links à l'aide d'OpenTelemetry et Signoz

1. SDK OpenTelemetry : le SDK OpenTelemetry (Software Development Kit) est votre boîte à outils pour collecter des données d'observabilité telles que des traces, des métriques et des journaux de votre application.

• Il agit comme un pont entre votre code et les systèmes d'observabilité, permettant de collecter des informations détaillées sur le fonctionnement de votre application.

• Imaginez OpenTelemetry comme une « caméra » qui capture des instantanés des opérations de votre application. En intégrant le SDK dans votre application, vous positionnez cette caméra pour enregistrer ce qui se passe dans les coulisses.

• Vous devrez installer le SDK dans le langage de programmation de votre application (par exemple, Python, Java, JavaScript).

(2) Configuration de SigNoz : SigNoz est un outil d'observabilité open source qui vous permet de visualiser et d'analyser les données que vous collectez avec OpenTelemetry.

• Considérez SigNoz comme la « salle de contrôle » où vous visualisez les images capturées par votre configuration OpenTelemetry. C'est là que vous avez une image claire des traces et des métriques dans votre application.

• Vous devrez configurer une instance SigNoz, ce qui implique de la déployer sur votre machine locale ou sur un serveur, généralement à l'aide de Docker ou de Kubernetes.

• SigNoz aide à transformer les données brutes en visualisations, comme des graphiques et des tableaux, ce qui facilite la compréhension de ce qui se passe dans votre application.

Connaissance de base des traces, des travées et du code d'instrumentation :

Traces :

En termes simples, une trace est comme une « histoire » de ce qui se passe lorsqu'un utilisateur ou une requête interagit avec votre application. Il capture toutes les actions qui se produisent à la suite de cette interaction, de la demande initiale à tous les services et bases de données qui pourraient être impliqués.

Imaginez un utilisateur cliquant sur un bouton de votre site Web. Une trace enregistrerait chaque étape de ce qui se passe ensuite.

Travées :

Les spans sont les « chapitres » de l'histoire d'une trace. Chaque span représente une opération ou une tâche spécifique qui a lieu dans le cadre d'une trace.

Par exemple, si la trace capture l'intégralité du processus d'une requête utilisateur, une période peut représenter une seule étape, comme interroger la base de données ou appeler une API externe.

Chaque période a une heure de début et de fin, vous donnant des détails précis sur la durée de chaque étape. Cela permet d'identifier plus facilement les ralentissements ou les erreurs.

Instrumenter le code avec OpenTelemetry :

L'instrumentation est le processus d'ajout de code à votre application pour collecter des données d'observabilité. En instrumentant votre code avec OpenTelemetry, cela implique généralement d'ajouter quelques lignes de code là où vous souhaitez créer des traces et des étendues.

Par exemple, vous pouvez instrumenter une requête de base de données pour voir combien de temps cela prend ou instrumenter un processus de connexion utilisateur pour suivre ses performances.

Le SDK OpenTelemetry facilite cela en fournissant des bibliothèques et des fonctions que vous pouvez intégrer directement dans votre code. Pensez-y comme si vous attachiez des trackers aux parties d’une machine pour surveiller leur fonctionnement ensemble.

Création de liens Span en Python : exemple étape par étape

Regardons un exemple de base en Python. Nous utiliserons le SDK OpenTelemetry pour créer deux spans et les relier ensemble.

from opentelemetry import trace
from opentelemetry.trace import Link
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter

# Set up the tracer provider and span exporter

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
span_processor = SimpleSpanProcessor(ConsoleSpanExporter())
trace.get_tracer_provider().add_span_processor(span_processor)

# Create the first span, simulating some work being done 

with tracer.start_as_current_span("span_one") as span_one:
    span_one.add_event("Processing order")
 order_id = "12345" # Imagine this as an order ID we're processing

# Create a second span with a link to the first span 

with tracer.start_as_current_span("span_two", links=[Link(span_one.get_span_context())]) as span_two:
        span_two.add_event("Updating order status")

# Simulate some additional work here

  print("Order ID: {order_id} has been updated.")

print("Tracing complete")

Explication de l'extrait de code Python ci-dessus

• Configurer le fournisseur de traceur :
  L'extrait de code ci-dessus commence par un fournisseur de traceur, qui gère la création de spans.

• Il est essentiel qu'OpenTelemetry sache comment gérer les spans. Nous configurons également un SimpleSpanProcessor et un ConsoleSpanExporter pour imprimer les données de span sur la console. Cela nous aide à voir quel type de travées sont créées et comment elles sont liées
  .

(2) Créer la première travée (span_one) :

À l'aide de la méthode tracer.start_as_current_span, nous créons un span appelé span_one. Cela peut représenter n'importe quelle action, comme le traitement d'une commande.

À l'intérieur de cette période, nous ajoutons un ordre de traitement des événements pour indiquer ce qui se passe à ce moment précis.

Nous simulons également un identifiant de commande (order_id = "12345") qui serait utilisé dans le prochain span.

(3) Créer la deuxième travée avec un lien (span_two) :

Ici, nous avons lancé un autre span appelé span_two pour représenter une action différente mais connexe, comme la mise à jour du statut de la commande.
Notez le paramètre links. Nous utilisons Link(span_one.get_span_context()) pour créer un lien entre span_two et span_one.

Cela indique à OpenTelemetry : "Bien que ces actions ne soient pas parent-enfant, elles sont liées."

Dans span_two, nous avons ajouté un autre événement, Mise à jour du statut de la commande, et simulé certains travaux comme la mise à jour du statut d'une commande dans une base de données.

(4) Sortie :

Lorsque vous exécutez ce code, vous verrez une sortie dans la console de ConsoleSpanExporter qui montre les deux étendues, ainsi que le lien entre elles. Cela permet de visualiser la relation entre ces deux étendues dans une trace.

Erreurs courantes à surveiller et comment résoudre les erreurs.

(1) Contextes d'étendue manquants :

Erreur : Si vous essayez de créer un lien sans appeler span_one.get_span_context(), vous obtiendrez une erreur car OpenTelemetry nécessite un contexte span valide pour créer un lien.

Solution : Assurez-vous toujours que vous transmettez un contexte span lors de la création d'un lien. Utilisez la méthode .get_span_context() d'un span actif.

(2) Liaison d'étendues non commencées ou terminées :

Erreur : Si vous essayez de créer un lien vers une période qui n'a pas été démarrée ou qui est déjà terminée, vous risquez de rencontrer des problèmes où le lien n'est pas reconnu.

Solution : Assurez-vous que le span vers lequel vous créez un lien est actif lorsque vous créez le lien. La création de liens avec des périodes déjà terminées peut entraîner un comportement inattendu dans la façon dont les traces sont affichées.

(3) Considérations relatives aux performances :

Problème de performances : La liaison d'un trop grand nombre d'étendues peut augmenter la surcharge des données de trace, entraînant une dégradation des performances dans les systèmes à fort trafic.

Solution : Utilisez les liens de manière sélective. Les liens ne s'étendent que lorsqu'il existe une relation significative que vous devez visualiser ou analyser. Pour les environnements à fort trafic, vous pouvez utiliser les options d'échantillonnage d'OpenTelemetry pour réduire la quantité de données de trace capturées.

Configuration de SigNoz pour la visualisation Span Link

Lorsque vous travaillez avec des systèmes distribués, il est crucial de comprendre comment les différentes parties de votre système communiquent. Les Les liens Span dans OpenTelemetry jouent un rôle essentiel dans la connexion des traces qui peuvent ne pas avoir de relation parent-enfant directe, fournissant ainsi une image plus claire de la façon dont les demandes transitent par vos services.

Pourquoi la visualisation des liens Span est importante

Imaginez que votre application dispose d'un service de paiement qui déclenche un service de notification lorsqu'un paiement est réussi. Bien que ces services interagissent, ils peuvent ne pas partager de relation directe parent-enfant.

Les liens Span vous permettent de relier ces interactions, montrant que le paiement a déclenché la notification. La visualisation de ces liens vous aide à avoir une vue d'ensemble de la corrélation entre les services indépendants en temps réel.

En configurant SigNoz pour visualiser ces liens span, vous pouvez obtenir des informations plus approfondies sur le comportement de votre application.

Voici comment configurer SigNoz pour capturer et afficher les liens Span

Étape 1 : Assurez-vous que SigNoz est correctement installé

• Pour commencer, assurez-vous que SigNoz est installé et exécuté sur votre environnement local ou dans une configuration cloud. SigNoz peut être déployé à l'aide de Docker pour une configuration facile.
• Si vous ne l'avez pas encore fait, suivez le guide d'installation officiel de SigNoz pour votre système d'exploitation [https://signoz.io/docs/introduction]
• Une fois installé, accédez à l'interface utilisateur de SigNoz en accédant à http://localhost:3301 dans votre navigateur Web. Cette interface vous permet de configurer les paramètres et de visualiser vos données de trace, y compris les liens span.

Étape 2 : Configurez le SDK OpenTelemetry pour inclure vos liens Span

L'étape suivante consiste à vous assurer que votre SDK OpenTelemetry est configuré pour envoyer des données de lien span à SigNoz. Dans le code de votre application, vous devrez ajouter des liens span dans le cadre de votre logique de traçage.

Voici un extrait de code en langage de programmation Python :

from opentelemetry import trace
from opentelemetry.trace import Link
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter

# Set up the tracer provider and span exporter

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
span_processor = SimpleSpanProcessor(ConsoleSpanExporter())
trace.get_tracer_provider().add_span_processor(span_processor)

# Create the first span, simulating some work being done 

with tracer.start_as_current_span("span_one") as span_one:
    span_one.add_event("Processing order")
 order_id = "12345" # Imagine this as an order ID we're processing

# Create a second span with a link to the first span 

with tracer.start_as_current_span("span_two", links=[Link(span_one.get_span_context())]) as span_two:
        span_two.add_event("Updating order status")

# Simulate some additional work here

  print("Order ID: {order_id} has been updated.")

print("Tracing complete")

Explication de l'extrait de code Python ci-dessus

Nous avons commencé par configurer TracerProvider pour gérer le traçage dans notre application et mettre en place un processeur span.

OTLPSpanExporter est utilisé pour envoyer des spans au backend de SigNoz à l'aide du protocole OTLP.

Remplacez http://localhost:4317 par le point de terminaison SigNoz approprié si vous n'exécutez pas SigNoz localement.

Deuxièmement, créer des travées et des liens :

Le parent_span est créé en premier, représentant une opération initiale (par exemple, une requête utilisateur). Nous extrayons le contexte du parent_span à l'aide de get_span_context(), ce qui nous permet d'y lier un autre span.

Le linked_span est ensuite créé et un lien est ajouté pour référencer le contexte du parent_span. Cela signifie que même si linked_span n'est pas un enfant direct de parent_span, il lui est lié.

Enfin, envoi de données à SigNoz :

Les données de span sont traitées à l'aide du BatchSpanProcessor, qui garantit que les données de span sont envoyées efficacement à SigNoz.

trace.get_tracer_provider().shutdown() est appelé à la fin pour garantir que toutes les étendues restantes sont vidées et exportées avant la fin du programme.

Étape 3 : Mettre à jour la configuration SigNoz pour les données de traçage

• Pour garantir que SigNoz capture les liens span, vous devrez peut-être modifier certains paramètres dans le fichier de configuration de votre collecteur SigNoz.
• Le collecteur agit comme un intermédiaire qui reçoit les données de trace de OpenTelemetry et les envoie au backend de SigNoz.
• Localisez le fichier de configuration OpenTelemetry Collector, souvent nommé otel-collector-config.yaml.
• Ajoutez ou mettez à jour les sections des processeurs et des exportateurs pour garantir que les données de trace sont correctement transmises. Par exemple:

from opentelemetry import trace
from opentelemetry.trace import SpanKind, Link
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

# Set up the tracer provider and add a span processor

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

# Configure the exporter to send spans to SigNoz using the OTLP exporter

otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)
span_processor = BatchSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# Create two spans, linking the second span to the context of the first

with tracer.start_as_current_span("parent_span") as parent_span:

# Simulate some logic for the parent_span
    print("Parent span is active")

# Get the context of the parent span
parent_context = parent_span.get_span_context()

# Create a linked span and add a link to the parent span's context

with tracer.start_as_current_span(
        "linked_span",
        links=[Link(parent_context)]
    ) as linked_span:

 # Simulate some logic for the linked_span
        print("Linked span is active")

# Ensure all spans are flushed before exiting the application

trace.get_tracer_provider().shutdown()

Étape 4 : Visualiser les liens Span dans SigNoz

Une fois que votre application envoie des données de trace avec des liens span à SigNoz, vous pouvez visualiser ces liens par :

• Ouverture de l'explorateur de traces dans l'interface utilisateur de SigNoz.
• Recherchez des traces liées aux services que vous surveillez (par exemple, le service de paiement et le service de notification).
• Dans la vue détaillée de la trace, vous verrez une représentation graphique des étendues, y compris les liens entre les étendues. Les travées liées apparaîtront sous forme de connexions supplémentaires entre les nœuds qui ne partagent pas de ligne parent-enfant directe.
• Cette visualisation vous aide à voir comment les demandes circulent dans votre système, même lorsque les services n'ont pas de relation hiérarchique stricte.

Étape 5 : Ajustez votre vue pour plus de clarté

Afin d'avoir une visualisation parfaite, vous devez prendre note des éléments suivants :

• Utilisez des filtres dans SigNoz pour affiner les données de trace à des services ou à des périodes spécifiques.
• Créez des tableaux de bord personnalisés pour suivre des liens spécifiques si vous surveillez fréquemment certaines interactions.
• Configurez des alertes dans SigNoz pour vous avertir lorsque des plages liées indiquent des problèmes potentiels, tels que des retards entre les services associés.

Prochaines étapes
Dans ce tutoriel, nous avons appris à utiliser les liens span pour suivre les interactions au sein des systèmes distribués

Dans le prochain didacticiel, nous apprendrons les meilleures pratiques d'utilisation des liens Span et les cas d'utilisation avancés

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!