Essayez « Comprendre OpenTelemetry » dans le Centre d'apprentissage

Apprenez les fondamentaux d'OpenTelemetry, y compris ses capacités et avantages, ses composants clés, et comment OTel et Datadog fonctionnent ensemble.

INSCRIVEZ-VOUS MAINTENANT

Présentation

OpenTelemetry est un framework d’observabilité open source qui fournit aux équipes informatiques des protocoles et des outils standardisés pour collecter et acheminer les données d’observabilité depuis des applications logicielles. OpenTelemetry fournit un format cohérent pour instrumentingL'instrumentation est le processus consistant à ajouter du code à votre application pour capturer et rapporter des données d'observabilité à Datadog, telles que des traces, des métriques et des logs., générer, rassembler et exporter des données d’observabilité d’application — à savoir des métriques, des logs et des traces — vers des plateformes de surveillance pour l’analyse et l’obtention d’informations exploitables.

Ce guide démontre comment configurer une application OpenTelemetry exemple pour envoyer des données d’observabilité à Datadog en utilisant le SDK OpenTelemetry, le collecteur OpenTelemetry et l’exportateur Datadog. Ce guide vous montre également comment explorer ces données dans l’interface utilisateur Datadog.

Suivez ce guide pour :

1. Instrumentez l’application avec l’API OpenTelemetry.
2. Configurez l’application pour envoyer des données d’observabilité à Datadog.
3. Corrélez les données d’observabilité avec le Unified Service Tagging.
4. Exécutez l’application pour générer des données d’observabilité.
5. Explorez les données d’observabilité dans l’interface utilisateur Datadog.

Prérequis

Pour compléter ce guide, vous avez besoin des éléments suivants :

1. Créez un compte Datadog si ce n’est pas déjà fait.
2. Configurez votre clé Datadog API :
   1. Trouvez ou créez votre clé Datadog API.
   2. Exportez votre clé Datadog API vers une variable d’environnement :
      Copy

      export DD_API_KEY=<Your API Key>

3. Récupérez l’application exemple Calendar.
   1. Clonez le dépôt opentelemetry-examples sur votre appareil :
      Copy

      git clone https://github.com/DataDog/opentelemetry-examples.git

   2. Accédez au répertoire /calendar :
      Copy

      cd opentelemetry-examples/apps/rest-services/java/calendar

4. Installez Docker Compose.
5. (Facultatif) Utilisez Linux pour envoyer des métriques d’infrastructure.

L’application Calendrier utilise les outils OpenTelemetry pour générer et collecter des métriques, des logs et des traces. Les étapes suivantes expliquent comment intégrer ces données d’observabilité dans Datadog.

Instrumentation de l’application

L’exemple d’application Calendar est déjà partiellement instrumenté :

1. Accédez au fichier CalendarService.java principal situé à : ./src/main/java/com/otel/service/CalendarService.java.

2. Le code suivant instrumente getDate() en utilisant les annotations et l’API OpenTelemetry :

   CalendarService.java

   @WithSpan(kind = SpanKind.CLIENT)
   public String getDate() {
       Span span = Span.current();
       span.setAttribute("peer.service", "random-date-service");
       ...
   }

Lorsque l’application Calendrier s’exécute, l’appel getDate() génère des traces et des spans.

Configuration de l’application

Récepteur OTLP

L’application Calendar est déjà configurée pour envoyer des données du SDK OpenTelemetry au récepteur du protocole OpenTelemetry (OTLP) dans le collector OpenTelemetry.

1. Accédez au fichier de configuration du collecteur situé à : ./src/main/resources/otelcol-config.yaml.

2. Les lignes suivantes configurent le récepteur OTLP pour recevoir des métriques, des traces et des logs :

   otelcol-config.yaml

   receivers:
     otlp:
       protocols:
         grpc:
           endpoint: 0.0.0.0:4317
         http:
           endpoint: 0.0.0.0:4318
   ...
   service:
     pipelines:
       traces:
         receivers: [otlp]
       metrics:
         receivers: [otlp]
       logs:
         receivers: [otlp]

Exportateur Datadog

L’exportateur Datadog envoie les données collectées par le récepteur OTLP au backend Datadog.

1. Accédez au fichier otelcol-config.yaml.

2. Les lignes suivantes configurent l’exportateur Datadog pour envoyer des données d’observabilité à Datadog :

   otelcol-config.yaml

   exporters:
     datadog:
       traces:
         compute_stats_by_span_kind: true
         trace_buffer: 500
       hostname: "otelcol-docker"
       api:
         key: ${DD_API_KEY}
         site: datadoghq.com
   
   connectors:
       datadog/connector:
         traces:
           compute_stats_by_span_kind: true
   
   service:
     pipelines:
       metrics:
         receivers: [otlp, datadog/connector] # <- update this line
         exporters: [datadog]
       traces:
         exporters: [datadog, datadog/connector]
       logs:
         exporters: [datadog]

3. Définissez exporters.datadog.api.site sur votre site Datadog. Sinon, la valeur par défaut est US1.

Cette configuration permet à l’exportateur Datadog d’envoyer des métriques d’exécution, des traces et des logs à Datadog. Cependant, l’envoi de métriques d’infrastructure nécessite une configuration supplémentaire.

Collecteur OpenTelemetry

Dans cet exemple, configurez votre collector OpenTelemetry pour qu’il envoie des métriques d’infrastructure.

Pour collecter les métriques de conteneur, configurez le récepteur Docker stats dans votre collecteur OpenTelemetry :

1. Ajoutez un bloc docker_stats à la section receivers de otel-config.yaml :

   otelcol-config.yaml

   receivers:
         otlp:
           protocols:
             grpc:
               endpoint: 0.0.0.0:4317
             http:
               endpoint: 0.0.0.0:4318
         # add the following block
         docker_stats:
           endpoint: unix:///var/run/docker.sock # default; if this is not the Docker socket path, update to the correct path
           metrics:
             container.network.io.usage.rx_packets:
               enabled: true
             container.network.io.usage.tx_packets:
               enabled: true
             container.cpu.usage.system:
               enabled: true
             container.memory.rss:
               enabled: true
             container.blockio.io_serviced_recursive:
               enabled: true
             container.uptime:
               enabled: true
             container.memory.hierarchical_memory_limit:
               enabled: true

2. Mettez à jour service.pipelines.metrics.receivers pour inclure docker_stats :

   otelcol-config.yaml

   service:
     pipelines:
       metrics:
         receivers: [otlp, datadog/connector, docker_stats] # <- update this line

Cette configuration permet à l’application Calendar d’envoyer des données sur les conteneurs à Datadog pour que vous puissiez les explorer dans Datadog.

Envoi de données d’observabilité avec OTLP

L’application Calendar utilise l’exportateur de logs OpenTelemetry dans sa configuration Logback pour envoyer des logs avec le composant de traitement OpenTelemetry (OTLP).

1. Accédez au fichier de configuration XML Logback de l’application Calendar à l’emplacement /src/main/resources/logback.xml.

2. Les lignes suivantes définissent l’appender OpenTelemetry :

   logback.xml

   <appender name="OpenTelemetry" class="io.opentelemetry.instrumentation.logback.appender.v1_0.OpenTelemetryAppender">
       <immediateFlush>true</immediateFlush>
       <captureExperimentalAttributes>true</captureExperimentalAttributes>
       <captureKeyValuePairAttributes>true</captureKeyValuePairAttributes>
     </appender>

3. La ligne <appender-ref ref="OpenTelemetry"/> fait référence à l’appender OpenTelemetry dans la configuration de niveau racine :

   logback.xml

   <root level="INFO">
     <appender-ref ref="console"/>
     <appender-ref ref="OpenTelemetry"/>
   </root>

De plus, des variables d’environnement configurent l’environnement OpenTelemetry pour exporter les logs, les métriques et les traces :

1. Accédez au fichier Docker Compose de l’application Calendar à l’emplacement ./deploys/docker/docker-compose-otelcol.yml.
2. La configuration OTEL_EXPORTER_OTLP_ENDPOINT=http://otelcol:4317 permet d’envoyer les métriques, les traces et les logs avec OTLP.

Corrélation des données d’observabilité

Le Unified Service Tagging relie les données d’observabilité dans Datadog, ce qui vous permet de naviguer entre les métriques, les traces et les logs à l’aide d’étiquettes cohérentes.

L’application Calendar est déjà configurée avec le Unified Service Tagging :

1. Accédez au fichier Docker Compose de l’application Calendar à l’emplacement ./deploys/docker/docker-compose-otelcol.yml.

2. Les lignes suivantes activent la corrélation entre les traces de l’application et les autres données d’observabilité :

   docker-compose-otelcol.yml

   environment:
     - OTEL_SERVICE_NAME=calendar-otel
     - OTEL_RESOURCE_ATTRIBUTES=deployment.environment=docker,host.name=otelcol-docker,service.version=<IMAGE_TAG>

Exécution de l’application

Pour commencer à générer et transmettre des données d’observabilité à Datadog, vous devez exécuter l’application Calendar avec le SDK OpenTelemetry :

1. Exécutez l’application depuis le dossier calendar/ :

   Copy

   docker compose -f deploys/docker/docker-compose-otelcol.yml up

   Cette commande crée un conteneur Docker avec le collector OpenTelemetry et le service Calendar.

2. Pour vérifier que l’application Calendar s’exécute correctement, exécutez la commande suivante depuis une autre fenêtre de terminal :

   Copy

   curl localhost:9090/calendar

3. Vérifiez que vous recevez une réponse telle que :

   Copy

   {"date":"2022-12-30"}

4. Exécutez la commande curl plusieurs fois pour vous assurer qu’au moins une trace est exportée vers le backend Datadog.

   L'application Calendar utilise le processeur d'échantillonnage probabiliste, de sorte que seuls 30 % des traces envoyées via l'application atteignent le backend cible.

Chaque appel à l’application Calendar entraîne la transmission de métriques, de traces et de logs vers le collector OpenTelemetry, puis vers l’exportateur Datadog, et enfin vers le backend Datadog.

Explorer les données d’observabilité dans Datadog

Utilisez l’interface Datadog pour explorer les données d’observabilité de l’application Calendar.

Remarque : Il peut s’écouler quelques minutes avant que vos données de trace n’apparaissent.

Métriques d’exécution et d’infrastructure

Affichez les métriques de runtime et d’infrastructure pour visualiser, surveiller et mesurer les performances de vos applications, hosts, conteneurs et processus.

1. Accédez à APM > Catalog.

2. Survolez le service calendar-otel et sélectionnez Full Page.

3. Faites défiler jusqu’au panneau inférieur et sélectionnez :

   • Infrastructure Metrics pour voir les métriques de votre conteneur Docker, telles que l’utilisation du processeur et de la mémoire.
   • JVM Metrics pour voir les métriques d’exécution, telles que l’utilisation du tas et le nombre de threads.

Logs

Consultez les logs pour surveiller et diagnostiquer les opérations de l’application et du système.

1. Accédez à Logs.
2. Si vous avez d’autres logs dans la liste, ajoutez @service.name:calendar-otel au champ Search for pour ne voir que les logs de l’application Calendar.
3. Sélectionnez un log dans la liste pour voir plus de détails.

Traces

Affichez les traces et les spans pour observer l’état et les performances des requêtes traitées par votre application.

1. Accédez à APM > Traces.

2. Recherchez la section Service dans le menu de filtrage et sélectionnez la facette calendar-otel pour afficher toutes les traces calendar-otel :

3. Explorez vos traces calendar-otel.

   Pour commencer, cliquez sur une trace pour ouvrir le panneau latéral de trace et trouver plus de détails sur la trace et ses spans. Par exemple, le Flame Graph capture le temps passé dans chaque composant du chemin d’exécution de Calendar :

4. Remarquez que vous pouvez sélectionner Infrastructure, Metrics ou Logs dans le panneau inférieur pour corréler votre trace avec d’autres données d’observabilité.

Pour aller plus loin

Documentation, liens et articles supplémentaires utiles:

Documentation OpenTelemetrySITE EXTERNE Documentation OpenTelemetry pour DatadogDOCUMENTATION Instrumentation personnalisée avec OpenTelemetryDOCUMENTATION Surveiller les métriques de runtime des applications instrumentées avec OTel dans la solution Datadog APMBLOG Mettre en corrélation les événements Datadog RUM avec les traces de vos applications instrumentées via OTelBLOG Envoyer des métriques et des traces depuis le Collector OpenTelemetry vers Datadog via l'exportateur DatadogBLOG Transmettre des logs depuis le Collector OpenTelemetry avec l'exportateur DatadogBLOG