Envoi de données de la démo OpenTelemetry vers Datadog

Documentation > OpenTelemetry dans Datadog > Getting Started with OpenTelemetry at Datadog > Envoi de données de la démo OpenTelemetry vers Datadog

Présentation

Ce tutoriel utilise l'exportateur Datadog et le connecteur Datadog. Pour les nouvelles configurations de Collector, Datadog recommande le pipeline OTLP dans Configurer le Collector OpenTelemetry.

La démo OpenTelemetry est une application de microservices développée par la communauté pour démontrer l’instrumentation OpenTelemetry (OTel) et ses capacités d’observabilité. Il s’agit d’une page web de commerce électronique composée de multiples microservices communiquant entre eux via HTTP et gRPC. Tous les services sont instrumentés avec OpenTelemetry et produisent des traces, des métriques et des logs.

Cette page vous guide à travers les étapes nécessaires pour déployer la démo OpenTelemetry et envoyer ses données vers Datadog.

Prérequis

Pour compléter ce guide, assurez-vous de disposer des éléments suivants :

Créez un compte Datadog si ce n’est pas déjà fait.
Trouvez ou créez votre clé Datadog API.
6 Go de RAM libre pour l’application.

Vous pouvez déployer la démo en utilisant Docker ou Kubernetes (avec Helm). Choisissez votre méthode de déploiement préférée et assurez-vous d’avoir installé les outils nécessaires :

Docker
Docker Compose v2.0.0+
Make (optionnel)

Kubernetes 1.24+
Helm 3.9+
Un cluster Kubernetes actif avec kubectl configuré pour s’y connecter

Configuration et déploiement de la démo

Clonage du dépôt

Clonez le dépôt opentelemetry-demo sur votre appareil :

git clone https://github.com/open-telemetry/opentelemetry-demo.git

Configuration de l’OpenTelemetry Collector

Pour envoyer les données de télémétrie de la démo à Datadog, vous devez ajouter les composants suivants à la configuration de l’OpenTelemetry Collector :

Resource Processor est un composant optional mais recommandé, utilisé pour définir l’attribut de ressource deployment.environment.name, que Datadog mappe vers le tag env.
Datadog Connector est responsable du calcul des métriques de trace Datadog APM.
Datadog Exporter est responsable de l’exportation des traces, des métriques et des logs vers Datadog.
Datadog Extension est un composant optional qui vous permet de visualiser la configuration de l’OpenTelemetry Collector au sein de la surveillance de l’infrastructure. (En savoir plus sur Datadog Extension).

Complétez les étapes suivantes pour configurer ces composants.

Ouvrez le dépôt de la démo. Créez un fichier nommé docker-compose.override.yml dans le dossier racine.

Ouvrez le fichier créé. Collez le contenu suivant et définissez les variables d’environnement Datadog site et Datadog API key :

services:
  otel-collector:
    command:
      - "--config=/etc/otelcol-config.yml"
      - "--config=/etc/otelcol-config-extras.yml"
      - "--feature-gates=datadog.EnableOperationAndResourceNameV2"
    environment:
      - DD_SITE_PARAMETER=<Your API Site>
      - DD_API_KEY=<Your API Key>

Pour configurer l’OpenTelemetry Collector, ouvrez src/otel-collector/otelcol-config-extras.yml et ajoutez ce qui suit au fichier :

extensions:
  datadog/extension:
    api:
      site: ${env:DD_SITE_PARAMETER}
      key: ${env:DD_API_KEY}
    http:
      endpoint: "localhost:9875"
      path: "/metadata"

exporters:
  datadog:
    traces:
      compute_stats_by_span_kind: true
      trace_buffer: 500
    api:
      site: ${env:DD_SITE_PARAMETER}
      key: ${env:DD_API_KEY}
    sending_queue:
      batch:
        min_size: 10
        max_size: 100
        flush_timeout: 10s

processors:
  resource:
    attributes:
      - key: deployment.environment.name
        value: "otel"
        action: upsert

connectors:
  datadog/connector:
    traces:
      compute_stats_by_span_kind: true

service:
  extensions: [datadog/extension]
  pipelines:
    traces:
      receivers: [otlp]
      processors: [resourcedetection, memory_limiter, resource, transform/sanitize_spans]
      exporters: [otlp_grpc/jaeger, debug, spanmetrics, datadog, datadog/connector]
    metrics:
      receivers: [datadog/connector, docker_stats, httpcheck/frontend-proxy, hostmetrics, nginx, otlp, postgresql, redis, spanmetrics]
      processors: [resourcedetection, memory_limiter, resource]
      exporters: [otlp_http/prometheus, debug, datadog]
    logs:
      receivers: [otlp]
      processors: [resourcedetection, memory_limiter, resource]
      exporters: [opensearch, debug, datadog]

By default, the collector in the demo application merges the configuration from two files:

src/otel-collector/otelcol-config.yml: contains the default configuration for the collector.
src/otel-collector/otelcol-config-extras.yml: used to add extra configuration to the collector.

Lors de la fusion de valeurs YAML, les objets sont fusionnés et les tableaux sont remplacés. C'est pourquoi davantage de composants sont spécifiés dans les pipelines qu'il n'y en a réellement de configurés. La configuration précédente ne remplace pas les valeurs configurées dans le principal otelcol-config fichier.

Créez un secret nommé dd-secrets pour stocker les secrets Datadog Site et API Key :

kubectl create secret generic dd-secrets --from-literal="DD_SITE_PARAMETER=<Your API Site>" --from-literal="DD_API_KEY=<Your API Key>"

Ajoutez le chart Helm OpenTelemetry à votre dépôt pour gérer et déployer la démo OpenTelemetry :
```
helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
```

Créez un fichier nommé my-values-file.yml avec le contenu suivant :

opentelemetry-collector:
  extraEnvsFrom:
    - secretRef:
        name: dd-secrets
  config:
    extensions:
      datadog/extension:
        api:
          site: ${env:DD_SITE_PARAMETER}
          key: ${env:DD_API_KEY}
        http:
          endpoint: "localhost:9875"
          path: "/metadata"
    exporters:
      datadog:
        traces:
          compute_stats_by_span_kind: true
          trace_buffer: 500
        hostname: "otelcol-helm"
        api:
          site: ${env:DD_SITE_PARAMETER}
          key: ${env:DD_API_KEY}
        sending_queue:
          batch:
            min_size: 10
            max_size: 100
            flush_timeout: 10s

    processors:
      resource:
        attributes:
          - key: deployment.environment.name
            value: "otel"
            action: upsert

    connectors:
      datadog/connector:
        traces:
          compute_stats_by_span_kind: true

    service:
      extensions: [health_check, datadog/extension]
      pipelines:
        traces:
          processors: [memory_limiter, resource, resourcedetection, transform]
          exporters: [otlp/jaeger, debug, spanmetrics, datadog, datadog/connector]
        metrics:
          receivers: [datadog/connector, otlp, spanmetrics]
          processors: [memory_limiter, resource, resourcedetection, transform]
          exporters: [otlphttp/prometheus, debug, datadog]
        logs:
          processors: [memory_limiter, resource, resourcedetection, transform]
          exporters: [opensearch, debug, datadog]

Exécution de la démo

Si make est installé, vous pouvez utiliser la commande suivante pour démarrer la démo :

make start

Si make n’est pas installé, vous pouvez utiliser directement la commande docker compose :

docker compose --env-file .env --env-file .env.override up --force-recreate --remove-orphans --detach

Pour déployer l’application de démo sur Kubernetes avec Helm, exécutez la commande suivante :

helm install my-otel-demo open-telemetry/opentelemetry-demo --values my-values-file.yml

Navigation dans l’application

Vous pouvez accéder à l’interface web de l’Astronomy Shop pour explorer l’application et observer comment les données de télémétrie sont générées.

Allez sur http://localhost:8080.

Si vous exécutez un cluster local, vous devez rediriger le port du proxy frontend :
```
kubectl port-forward svc/my-otel-demo-frontendproxy 8080:8080
```
Allez sur http://localhost:8080.

Corrélation des données de télémétrie

Les étapes d’instrumentation utilisées dans tous les services de la démo se trouvent dans la documentation principale d’OpenTelemetry.

Vous pouvez trouver le langage dans lequel chaque service a été implémenté ainsi que sa documentation dans le tableau de référence des fonctionnalités linguistiques.

Explorer les données OpenTelemetry dans Datadog

Lorsque la démo OTel est en cours d’exécution, le générateur de charge intégré simule du trafic dans l’application. Après quelques secondes, vous pouvez voir les données arriver dans Datadog.

Catalog

Affichez tous les services qui font partie de la démo OTel :

Allez dans APM > Catalog.

Voir la page du catalogue avec la liste des services de l'application de démo OpenTelemetry

Sélectionnez Map pour voir comment les services sont connectés. Changez Map layout pour Cluster ou Flow pour voir la carte dans différents modes.

Voir le flux de la Service Map avec tous les services connectés

Sélectionnez la vue Catalog, puis sélectionnez un service pour voir un résumé des performances dans le panneau latéral.

Voir le résumé des performances et les conseils de configuration d'un service spécifique

Trace Explorer

Explorez les traces reçues de la démo OTel :

Depuis Performance > Setup Guidance, cliquez sur View Traces pour ouvrir Trace Explorer, avec le service sélectionné appliqué comme filtre.

Vue des traces avec tous les spans indexés pour le service checkout

Sélectionnez un span indexé pour voir les détails complets de la trace pour cette transaction.

Vue de trace avec tous les spans appartenant à cette transaction spécifique

Naviguez à travers les onglets pour voir des détails supplémentaires :
- Métriques d’infrastructure pour les services rapportant des Host Metrics.
- Métriques d’exécution pour les services qui ont déjà été implémentés.
- Entrées de log corrélées avec cette trace.
- Liens de span liés à cette trace.

Requêtes de trace

Datadog vous permet de filtrer et de regrouper les données OpenTelemetry reçues. Par exemple, pour trouver toutes les transactions d’un utilisateur spécifique, vous pouvez utiliser les requêtes de trace :

La démo OTel envoie user.id sous forme de tags de span, vous pouvez donc l’utiliser pour filtrer toutes les transactions déclenchées par l’utilisateur :

Depuis Info dans le panneau latéral, survolez la ligne avec l’identifiant utilisateur, cliquez sur l’icône cog et sélectionnez filter by @app.user.id:<user_id>.
Supprimez tous les filtres précédents, en ne laissant que @app.user.id appliqué pour afficher toutes les transactions contenant des spans avec l’identifiant utilisateur spécifié.

Requête de trace filtrant tous les spans qui contiennent un app.user.id spécifique

Error Tracking

La démo OpenTelemetry inclut un feature flag engine pour simuler des scénarios d’erreur.

Accédez à http://localhost:8080/feature pour gérer les scénarios disponibles. Consultez la documentation de la démo OpenTelemetry pour plus de détails.
Une fois que la démo commence à produire des erreurs, vous pouvez visualiser et localiser les services affectés dans Datadog.