Managed Service for OpenTelemetry:Use Jaeger to report trace data from a Python application

Fonctionnement

Jaeger prend en charge deux architectures de rapport de données :

• Sans l'agent Jaeger : le client Jaeger envoie directement les données de traçage au backend de Managed Service for OpenTelemetry.

• Avec l'agent Jaeger : le client Jaeger envoie les données de traçage à un agent Jaeger exécuté localement, qui les transfère ensuite au backend via gRPC.

Limites

• Le client Python Jaeger (v1.25) ne peut envoyer des données de traçage que via l'agent Jaeger, et non par HTTP. Consultez la documentation Fonctionnalités de la bibliothèque cliente.

• Le client communique avec l'agent via UDP, un protocole qui ne garantit pas la livraison des paquets. Pour minimiser la perte de données, exécutez les deux composants sur le même hôte.

Étape 1 : Démarrer l'agent Jaeger

1. Téléchargez l'image de l'agent Jaeger :

      docker pull jaegertracing/jaeger-agent:1.25

2. Démarrez le conteneur de l'agent Jaeger. Remplacez les espaces réservés suivants par les valeurs issues de la page Cluster Configurations :

   Espace réservé	Description
   <endpoint>	Endpoint gRPC de Managed Service for OpenTelemetry
   <auth>	Jeton d'authentification

      docker run -d --name jaeger-agent \
        -p 5775:5775/udp \
        -p 6831:6831/udp \
        -p 6832:6832/udp \
        -p 5778:5778/tcp \
        jaegertracing/jaeger-agent:1.25 \
        --reporter.type=grpc \
        --reporter.grpc.host-port=<endpoint> \
        --agent.tags=<auth>

3. Vérifiez que l'agent est en cours d'exécution. Un statut Up confirme que l'agent a démarré correctement. Si le conteneur n'est pas actif, consultez les journaux :

      docker ps --filter name=jaeger-agent

      docker logs jaeger-agent

Étape 2 : Instrumenter l'application Python

1. Installez les packages requis. Enregistrez le contenu suivant dans un fichier requirements.txt, puis installez les packages :

      certifi==2021.5.30
      charset-normalizer==2.0.4
      idna==3.2
      jaeger-client==4.6.0
      opentracing==2.4.0
      requests==2.26.0
      six==1.16.0
      threadloop==1.0.2
      thrift==0.13.0
      tornado==6.1
      urllib3==1.26.6

      pip install -r requirements.txt

2. Créez un fichier Python (par exemple, tracing_demo.py) contenant le code ci-dessous. Voici les paramètres de configuration clés :

   Paramètre	Valeur	Description
   sampler.type	const	Échantillonne chaque trace. Pour la production, utilisez probabilistic avec une valeur param plus faible.
   sampler.param	1	Avec le type const, 1 signifie échantillonner toutes les traces, tandis que 0 signifie n'en échantillonner aucune.
   reporting_host	127.0.0.1	Adresse de l'agent Jaeger. Utilisez 127.0.0.1 lorsque l'agent s'exécute sur le même hôte.
   reporting_port	6831	Port UDP sur lequel l'agent Jaeger écoute les spans.
   service_name	mytest3	Nom identifiant votre application dans la console ARMS.

      import logging
      import time
      from jaeger_client import Config
   
      def construct_span(tracer):
          with tracer.start_span('AliyunTestSpan') as span:
              span.log_kv({'event': 'test message', 'life': 42})
              print("tracer.tags: ", tracer.tags)
              with tracer.start_span('AliyunTestChildSpan', child_of=span) as child_span:
                  span.log_kv({'event': 'down below'})
              return span
   
      if __name__ == "__main__":
          log_level = logging.DEBUG
          logging.getLogger('').handlers = []
          logging.basicConfig(format='%(asctime)s %(message)s', level=log_level)
   
          config = Config(
              config={
                  'sampler': {
                      'type': 'const',  # Sample every trace. Use 'probabilistic' in production.
                      'param': 1,
                  },
                  'local_agent': {
                      # The Jaeger agent address. Keep this as 127.0.0.1 when the agent
                      # runs on the same host, which is recommended for UDP reliability.
                      'reporting_host': '127.0.0.1',
                      'reporting_port': 6831,
                  },
                  'logging': True,
              },
              service_name="mytest3",  # Replace with your application name.
              validate=True
          )
   
          # Initialize the tracer. This also sets opentracing.tracer.
          tracer = config.initialize_tracer()
   
          span = construct_span(tracer)
   
          # Allow the IOLoop to flush buffered spans before closing.
          # See: https://github.com/jaegertracing/jaeger-client-python/issues/50
          time.sleep(2)
          tracer.close()

3. Exécutez le fichier. Lors d'une initialisation réussie, la sortie de débogage affiche la configuration du traceur et confirme que les spans sont envoyés à l'agent Jaeger.

      python tracing_demo.py

Vérifier les données de traçage dans la console

1. Connectez-vous à la console ARMS. Dans le volet de navigation de gauche, sélectionnez Application Monitoring > Applications.

2. Sur la page Applications, sélectionnez une région dans la barre de navigation supérieure, puis cliquez sur le nom de votre application.

   Remarque

   Si l'icône apparaît dans la colonne Language, l'application utilise Application Monitoring. Un tiret (-) indique Managed Service for OpenTelemetry.

3. Dans la section Application Overview, vérifiez les métriques de performance clés et la topologie.

   L'onglet Overview Analysis de la page Application Overview affiche les métriques principales suivantes :

   • Total Requests : nombre de requêtes, avec les variations hebdomadaires et quotidiennes.

   • Average Response Time : temps de réponse et sa tendance.

   • Exceptions : nombre de requêtes anormales.

   • Span Count : nombre total de spans dans la trace.

   Sous ces métriques, les zones Services Provided et Dependent Services affichent chacune des graphiques linéaires représentant le volume de requêtes et le temps de réponse moyen.

4. Dans le volet de navigation de gauche, cliquez sur Application Details. L'onglet Overview affiche le résumé de l'application.

   Sur la page Application Details, l'onglet Overview s'affiche par défaut. Il présente la topologie de l'application ainsi que trois graphiques de surveillance : Requests, response time et Exceptions. La liste des services à gauche indique le temps de réponse, le nombre de requêtes et le nombre d'exceptions pour chaque interface.

5. Cliquez sur l'onglet Traces pour consulter les données de traçage envoyées par votre application.

Résoudre les problèmes de données de traçage manquantes

Si les données de traçage n'apparaissent pas dans la console après l'exécution de votre application, vérifiez les points suivants :

Opérations courantes avec Jaeger

Les exemples suivants couvrent les opérations de traçage Jaeger les plus fréquentes. Pour plus de détails, consultez la documentation Getting Started.

from jaeger_client import Config

def init_jaeger_tracer(service_name='your-app-name'):
    config = Config(config={}, service_name=service_name)
    return config.initialize_tracer()

# Start a root span (no parent).
tracer.start_span('TestSpan')

# Start a child span.
tracer.start_span('ChildSpan', child_of=span)

# Finish the span.
span.finish()

# Inject: serialize the SpanContext into a carrier for downstream services.
tracer.inject(
    span_context=span.context, format=Format.TEXT_MAP, carrier=carrier
)

# Extract: deserialize the SpanContext from an incoming request.
span_ctx = tracer.extract(format=Format.TEXT_MAP, carrier={})