Maîtriser l'analyse de traces avec Span Links à l'aide d'openTelemetry et Signoz (Un guide pratique, partie 2)

Dans le didacticiel précédent, nous avons appris à utiliser les liens span pour suivre les interactions au sein des systèmes distribués

Dans ce didacticiel, nous verrons comment mettre en œuvre les meilleures pratiques d'utilisation des liens Span et les cas d'utilisation avancés

Meilleures pratiques d'utilisation des liens Span dans OpenTelemetry

Lorsqu'il s'agit de systèmes distribués complexes, le choix de la bonne stratégie de traçage est essentiel pour maintenir la clarté et les performances.

Dans OpenTelemetry, les deux principaux outils à votre disposition sont les relations parent-enfant et les liens span. Explorons quand et comment utiliser efficacement les liens span, en particulier par rapport aux relations parent-enfant les plus courantes.

1. Quand utiliser les liens Span et les relations parent-enfant

Comprendre quand utiliser les liens span plutôt que les traces parent-enfant est crucial pour cartographier correctement la manière dont vos services communiquent.

Relation parent-enfant : le modèle de traçage standard

Les relations parent-enfant dans le traçage sont simples. Si un service en appelle un autre, la trace crée un lien parent-enfant direct entre les deux étendues. La durée enfant dépend de la durée parent, montrant clairement le flux des opérations.

Ce modèle fonctionne bien dans les opérations synchrones, où une tâche en déclenche directement une autre, et elles suivent une progression linéaire, telle que :

• Une requête utilisateur déclenche une fonction.
• La fonction appelle une base de données.
• La base de données renvoie une réponse.
• Chacune de ces actions serait un enfant de la précédente, formant une trace nette et séquentielle.

Liens span

Dans les systèmes du monde réel, en particulier ceux utilisant des microservices ou des processus asynchrones, toutes les opérations ne suivent pas ce flux hiérarchique soigné. C'est là que les liens span deviennent précieux.

Un lien de travée vous permet de connecter deux travées qui peuvent ne pas suivre un modèle de cause à effet direct. Par exemple :

Tâches asynchrones : une file d'attente de messages peut envoyer une demande à un service de traitement, mais vous pouvez également souhaiter connecter cette demande au service d'origine qui l'a déclenchée.

Tâches par lots : vous pouvez disposer d'un système qui traite les données par lots, dans lequel plusieurs tâches enfants sont liées à un seul événement déclencheur, mais ces tâches ne s'exécutent pas de manière séquentielle.

Processus où les liens Span ajoutent de la valeur :

Systèmes découplés ou asynchrones :
Où un processus en déclenche un autre, mais il n’y a pas d’appel direct.

Parents multiples : Si plusieurs processus contribuent à un résultat (par exemple, les données de plusieurs services sont regroupées dans un seul rapport), les liens d'étendue vous permettent de connecter toutes les étendues associées.

Événements corrélés : Les liens Span sont idéaux lorsque vous devez associer des étendues de différentes traces, par exemple lorsqu'une défaillance dans un service provoque indirectement une erreur dans un autre.

Processus qui rendent Span Links redondant :

Opérations synchrones : Si la relation entre les tâches est directe et synchrone, les liens span peuvent encombrer votre visualisation de trace sans ajouter de valeur réelle. Dans ce cas, tenez-vous-en aux relations parent-enfant par souci de simplicité.

Utilisez des stratégies d'échantillonnage avec Span Links pour optimiser les performances de traçage :

Dans les systèmes à fort trafic, il n'est pas nécessaire de capturer chaque travée ou lien. L'échantillonnage est une stratégie dans laquelle seule une partie des traces est enregistrée, garantissant que vous capturez suffisamment de données pour l'analyse sans surcharger votre système.

Échantillonnage basé sur la tête : Cela capture les traces au point d'entrée (tête) de votre système. Vous pouvez appliquer cela aux services clés, en vous assurant que les liens span ne sont créés que pour les traces hautement prioritaires ou importantes.

Échantillonnage basé sur la queue : Cet échantillonne les traces en fonction du résultat, par exemple en capturant uniquement les traces qui entraînent des erreurs. Vous pouvez l'utiliser pour garantir que les liens span sont utilisés dans les cas les plus susceptibles de nécessiter une enquête approfondie, tels que les échecs.

2. Nommer et structurer les liens Span pour plus de clarté

De bonnes conventions de dénomination et des traces structurées sont importantes afin d'avoir des données d'observabilité parfaites, en particulier lorsque des liens de travée sont impliqués. Le nom d'une travée doit clairement décrire ce qu'elle représente. Cela devient plus important lors de l'utilisation de liens de travée, car la relation entre les travées n'est pas toujours visuellement évidente.

Conventions de dénomination cohérentes :

Utilisez un modèle cohérent pour les noms de span, par exemple en incluant le nom du service, la fonction ou l'action. Par exemple, un span pour un service de traitement des paiements peut être nommé payment-service.processPayment.

Indiquez le rôle des travées liées :

Dans vos noms de span, indiquez le rôle du span lié si pertinent. Par exemple, user-authentication.request pourrait être lié à session-creation.init, rendant ainsi le lien entre eux clair.

Spans associés au groupe : les spans de groupe sont logiques. Par exemple, si plusieurs microservices contribuent à un processus plus vaste, assurez-vous que les liens et la dénomination du span aident à identifier quel service est responsable de chaque partie.

Raisons du lien vers le document : Si possible, documentez pourquoi un lien span existe, soit dans la trace elle-même (via des métadonnées), soit dans votre documentation. Cela peut être aussi simple qu'un bref commentaire dans le code de traçage expliquant la relation entre deux travées.

Cas d'utilisation avancés Suivi des erreurs pour l'utilisation de Span Links dans vos applications

Comment utiliser les liens Span pour tracer les flux d'erreurs entre les services

Imaginez que vous gérez une application Web complexe avec de nombreux microservices, chaque microservice est responsable d'une partie différente de l'expérience utilisateur.

Un utilisateur peut passer une commande, ce qui déclenche un service de paiement, un service d'inventaire et un service d'expédition. Si une erreur se produit quelque part dans cette chaîne, il est crucial de savoir où elle s’est produite et comment elle a impacté les autres services. C'est là qu'interviennent les liens span.

Les liens Span vous permettent de connecter des traces qui ne sont pas dans une relation parent-enfant directe, mais qui ont toujours une pertinence contextuelle. En utilisant les liens Span pour le suivi des erreurs, vous pouvez corréler l'erreur dans un service avec l'impact ultérieur sur d'autres services. , même s'ils ne partagent pas de relation directe.

Cas d'utilisation : Supposons que votre service de paiement rencontre une erreur en essayant de traiter une transaction, et que cet échec affecte indirectement le service d'expédition. À l'aide d'un lien d'intervalle, vous pouvez créer une relation entre l'intervalle d'erreur du service de paiement et l'intervalle du service d'expédition qui a détecté le problème.

Cela vous aide à visualiser le flux de l'erreur entre les services et à comprendre ses effets d'entraînement.

Exemple de code pour capturer et lier les erreurs entre les microservices

Voyons comment vous pourriez capturer ces erreurs à l'aide d'OpenTelemetry et créer des liens span entre elles. Voici un exemple simple utilisant Python :

from opentelemetry import trace

# Initialize tracer
tracer = trace.get_tracer("order-service")

# Create a span in the payment service
with tracer.start_as_current_span("payment-processing") as payment_span:
    try:
        # Simulate a payment process that raises an error
        process_payment()
    except Exception as e:
        payment_span.record_exception(e)
        payment_span.set_status(trace.Status(trace.StatusCode.ERROR, str(e)))

        # Capture the error trace and create a span link
        error_link = trace.Link(payment_span.get_span_context())

# Now in the shipping service, you can link this error trace
with tracer.start_as_current_span("shipping-service", links=[error_link]) as shipping_span:
    # Handle the impact of the payment error here
    process_shipping()

Explication de l'extrait de code ci-dessus

La durée de traitement du paiement capture l'erreur lorsque le paiement échoue.
Un lien span (error_link) est créé en utilisant le contexte du span de traitement des paiements.

Ce lien est ensuite ajouté à la durée du service d'expédition, vous permettant de retracer comment l'erreur de paiement affecte le processus d'expédition.

Vous pouvez utiliser des outils tels que SigNoz pour visualiser ces erreurs, ce qui simplifie grandement l'identification de la cause première des problèmes.

Implémentation de liens Span dans des architectures de microservices complexes

Cas d'utilisation réel : utilisation de Span Links pour suivre les interactions clients dans une architecture multiservice

Prenons un scénario du monde réel. Imaginez une plateforme de commerce électronique où les actions des clients, comme passer une commande, sont gérées par plusieurs services : Service de commande, service d'inventaire, service de paiement et service d'expédition.

Un utilisateur passant une seule commande peut générer plusieurs délais, un pour chaque service.

Maintenant, ces délais sont généralement organisés dans une relation parent-enfant, où le service de commande peut être le parent du service de paiement, etc. Mais que se passe-t-il si vous souhaitez suivre une relation plus complexe ?

Par exemple, si le service d'inventaire vérifie indépendamment les niveaux de stock après une confirmation de paiement, ce n'est pas un enfant direct du service de paiement. Un lien span vous permet de connecter directement ces services, créant ainsi une image plus précise de la façon dont vos services interagissent.

Pourquoi Span Links est important dans les architectures complexes

Les liens Span vous offrent la flexibilité nécessaire pour capturer ces interactions non linéaires, offrant ainsi une vue complète des actions des utilisateurs qui s'étendent sur tous les services. Ceci est particulièrement utile pour dépanner les expériences des utilisateurs, comme un envoi retardé en raison d'une vérification d'inventaire.

Comment les liens Span améliorent l'observabilité dans les systèmes sans serveur ou pilotés par événements

Dans les systèmes sans serveur ou pilotés par événements, les services interagissent souvent de manière découplée, les événements déclenchent des actions sans que les services se connaissent directement.

Par exemple, un événement provenant d'un service de paiement peut déclencher un service de mise à jour d'inventaire via un bus d'événements. Étant donné que ces services n’ont pas de relation parent-enfant, les retrouver avec les méthodes traditionnelles peut s’avérer difficile.

Comment utiliser les liens Span pour le sans serveur

Les liens Span peuvent servir de ciment entre ces services disjoints. Lorsqu'un événement est généré à partir d'un service et consommé par un autre, vous pouvez créer un lien d'étendue qui relie l'étendue de l'événement d'origine à l'étendue du service consommateur.

De cette façon, même si vos fonctions sans serveur s'exécutent indépendamment, vous pouvez toujours obtenir l'histoire complète d'une interaction.

Exemple : disons que votre service de paiement envoie un message à une file d'attente après avoir traité un paiement, et que ce message déclenche une fonction de mise à jour des stocks dans une architecture sans serveur.

Voici un extrait de code expliquant comment lier ces étendues

from opentelemetry import trace

# Initialize tracer
tracer = trace.get_tracer("order-service")

# Create a span in the payment service
with tracer.start_as_current_span("payment-processing") as payment_span:
    try:
        # Simulate a payment process that raises an error
        process_payment()
    except Exception as e:
        payment_span.record_exception(e)
        payment_span.set_status(trace.Status(trace.StatusCode.ERROR, str(e)))

        # Capture the error trace and create a span link
        error_link = trace.Link(payment_span.get_span_context())

# Now in the shipping service, you can link this error trace
with tracer.start_as_current_span("shipping-service", links=[error_link]) as shipping_span:
    # Handle the impact of the payment error here
    process_shipping()

Avec cette configuration, vous pouvez retracer le flux depuis le traitement des paiements jusqu'à la mise à jour des stocks, même s'ils fonctionnent de manière asynchrone.

Une fois visualisé, il devient clair comment les différentes parties de votre application sans serveur interagissent, améliorant ainsi votre capacité à diagnostiquer les goulots d'étranglement ou les retards inattendus.

Pourquoi cette approche est-elle importante pour l'observabilité

La surveillance traditionnelle peut vous montrer qu'une mise à jour de stock a été lente, mais avec les liens span, vous pouvez retracer ce retard jusqu'à l'événement de paiement spécifique qui l'a déclenché.

Ce niveau d'informations est inestimable pour optimiser votre système et garantir une expérience utilisateur fluide.

Récapitulatif des enseignements clés :

Les liens Span sont une puissante fonctionnalité sous-utilisée d'OpenTelemetry qui peut améliorer considérablement la corrélation des traces dans les systèmes distribués.

Mais qu'est-ce que cela signifie exactement, et pourquoi devriez-vous vous en soucier ?

Imaginez votre application comme un réseau de différents services et processus, tous communiquant et travaillant ensemble pour répondre aux demandes des utilisateurs. Vous rencontrerez souvent des scénarios dans lesquels une simple relation parent-enfant entre les traces ne rend pas tout à fait compte de la complexité de ce qui se passe.

Par exemple, que se passe-t-il si une tâche en arrière-plan traite des événements déclenchés par une action de l'utilisateur ou si plusieurs services travaillent ensemble de manière asynchrone ? C'est là qu'interviennent les liens span pour résoudre le défi facilement.

Alors, quels sont les avantages de l'utilisation des liens span ?

Relier les durées au-delà des contraintes parent-enfant :

Les liens Span vous permettent de connecter des traces entre services sans être lié par la structure hiérarchique typique des spans parents et enfants.

Ceci est particulièrement utile lorsque vous souhaitez relier des événements qui se produisent simultanément ou qui partagent un contexte commun mais qui n'ont pas de relation parent-enfant directe. Par exemple, lier une trace d'un service destiné aux utilisateurs à un processus en arrière-plan peut vous donner une vue plus globale de l'impact des actions des utilisateurs sur les performances du système.

Cela aide à améliorer le débogage et le dépannage :

Avec les liens span, vous obtenez une perspective plus riche sur la façon dont les différents services interagissent, en particulier lors de flux de travail complexes. En voyant quelles étendues sont liées via des liens, vous pouvez identifier les goulots d'étranglement, les modèles d'erreur ou les problèmes de performances qui pourraient être difficiles à détecter autrement. Cela fait des liens span un outil puissant pour déboguer les problèmes qui couvrent plusieurs services.

Il offre une meilleure visibilité dans les systèmes asynchrones :

Pour les applications qui s'appuient sur un traitement asynchrone, telles que celles utilisant des files d'attente de messages ou des architectures basées sur les événements, les liens span sont inestimables.

Ils vous permettent de retracer le cycle de vie d'une tâche ou d'un message à mesure qu'il transite par différents services. Cela peut vous aider à comprendre l'impact d'un événement unique sur l'ensemble de votre système, facilitant ainsi l'optimisation et l'affinement de vos processus.

En bref, les liens span vous permettent de créer une image plus connectée et significative du comportement de votre application, conduisant à une meilleure observabilité et à une compréhension plus approfondie du fonctionnement de vos systèmes distribués.

En exploitant efficacement les liens span, vous pouvez améliorer la corrélation des traces, ce qui accélère le dépannage et offre une vue plus complète des performances de votre système.

Liens vers la documentation OpenTelemetry pertinente pour les liens Span

Pour ceux qui souhaitent approfondir les conseils officiels sur les liens span et les concepts associés, les ressources suivantes seront précieuses pour votre recherche :

Documentation des liens OpenTelemetry Span

Il s'agit de la référence incontournable pour comprendre comment créer et gérer des liens span. Il couvre les spécifications de l'API pour la liaison des étendues, avec des exemples dans divers langages de programmation pris en charge. C'est un excellent point de départ pour comprendre les détails techniques du fonctionnement des liens de travée sous le capot.

Propagation du contexte OpenTelemetry

Comprendre la propagation du contexte est essentiel pour tirer le meilleur parti des liens span, et cette documentation fournit un aperçu complet de la façon dont le contexte est géré entre les traces. C’est particulièrement utile si vous cherchez à assurer la cohérence de vos données de traçage sur l’ensemble des services distribués.

Stratégies d'échantillonnage OpenTelemetry

Lors de la mise en œuvre de liens span, il est crucial de savoir comment l'échantillonnage affecte vos traces. Cette section de la documentation fournit des conseils détaillés sur la façon de configurer différentes stratégies d'échantillonnage, vous aidant ainsi à trouver le bon équilibre entre granularité des données et performances.

Ces liens sont des ressources précieuses à la fois pour la référence et l'application pratique, ce qui les rend essentiels pour toute personne désireuse de maîtriser les capacités de traçage d'OpenTelemetry. Ajoutez ces ressources à vos favoris et utilisez-les comme guide lorsque vous créez des configurations d'observabilité plus complexes.

Si vous avez des questions ou des explications complémentaires, veuillez les partager dans les sections commentaires.

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!