Datadog

La plateforme d'observabilité et de monitoring qui unifie métriques, traces et logs pour offrir une vision complète de la santé et des performances de votre infrastructure et de vos applications.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce que Datadog ?

Imaginez que vous gérez un grand restaurant. Pour vous assurer que tout fonctionne correctement, vous devez surveiller plusieurs aspects : la rapidité du service, la qualité des plats, la satisfaction des clients, les niveaux de stock, et bien plus encore.

Datadog est comme un système de surveillance sophistiqué pour vos applications et infrastructures informatiques. Il collecte des données de toutes les parties de votre environnement technique et les présente de manière claire et actionnable.

Pourquoi est-ce important ?

Détection rapide des problèmes

Identifiez les problèmes avant qu'ils n'affectent vos utilisateurs, comme remarquer qu'un four commence à surchauffer avant qu'il ne tombe en panne.

Vue unifiée

Avoir une vue d'ensemble de tous les systèmes sur un seul écran, comme un tableau de bord qui affiche l'état de la cuisine, de la salle à manger et des réservations.

En résumé, Datadog aide les entreprises à s'assurer que leurs applications et services informatiques fonctionnent correctement, en fournissant des alertes précoces en cas de problème et des informations détaillées pour diagnostiquer et résoudre rapidement ces problèmes.

Pour les développeurs

Fonctionnement technique

Datadog est une plateforme d'observabilité SaaS (Software as a Service) qui intègre et automatise l'infrastructure monitoring, l'APM (Application Performance Monitoring), les logs, et le monitoring des expériences utilisateurs (RUM) dans une solution unifiée, parfaitement compatible avec AWS Lambda et d'autres services cloud.

Composants principaux

Datadog Agent

L'agent Datadog est un logiciel léger qui s'exécute sur vos hôtes (serveurs, conteneurs, machines virtuelles) et collecte des métriques, des traces et des logs. Voici un exemple de configuration de l'agent :

Configuration de l'agent Datadog

# /etc/datadog-agent/datadog.yaml
api_key: your_api_key_here

# Options de collecte
logs_enabled: true
apm_enabled: true
process_config:
  enabled: true

# Configurations des logs
logs_config:
  processing_rules:
    - type: mask_sequences
      name: mask_passwords
      replace_placeholder: "[MASKED]"
      pattern: "password=[^\s]*"

# Configurations des intégrations
use_dogstatsd: true
dogstatsd_port: 8125

# Tags globaux
tags:
  - env:production
  - region:eu-west-3
  - service:api-gateway

Real User Monitoring (RUM)

Le RUM permet de suivre les performances et le comportement des utilisateurs sur votre application web ou mobile :

Intégration du RUM Datadog dans une application web

import { datadogRum } from '@datadog/browser-rum';

datadogRum.init({
  applicationId: 'your-application-id',
  clientToken: 'your-client-token',
  site: 'datadoghq.eu',
  service: 'my-web-application',
  env: 'production',
  version: '1.0.0',
  trackInteractions: true,
  defaultPrivacyLevel: 'mask-user-input'
});

datadogRum.startSessionReplayRecording();

// Ajout d'un timing personnalisé
const startTime = performance.now();
// ... exécution d'une opération ...
const endTime = performance.now();

datadogRum.addUserAction('custom_timing', {
  name: 'product_search',
  time: endTime - startTime
});

// Ajout d'informations utilisateur
datadogRum.setUser({
  id: 'user-123',
  name: 'John Doe',
  email: 'john.doe@example.com',
  plan: 'premium'
});

API Datadog

L'API Datadog permet d'intégrer programmatiquement la plateforme dans vos applications et workflows :

Utilisation de l'API Datadog

// Exemple d'envoi de métriques custom via l'API Datadog
const axios = require('axios');

async function sendMetric() {
  const now = Math.floor(Date.now() / 1000);
  
  try {
    const response = await axios.post('https://api.datadoghq.eu/api/v1/series', {
      series: [{
        metric: 'app.request.count',
        points: [[now, 1]],
        type: 'count',
        tags: ['endpoint:checkout', 'environment:production']
      }]
    }, {
      headers: {
        'Content-Type': 'application/json',
        'DD-API-KEY': process.env.DATADOG_API_KEY,
        'DD-APPLICATION-KEY': process.env.DATADOG_APP_KEY
      }
    });
    
    console.log('Métrique envoyée avec succès:', response.data);
  } catch (error) {
    console.error('Erreur lors de l'envoi de la métrique:', error);
  }
}

// Envoi d'une alerte via l'API Datadog
async function createIncident() {
  try {
    const response = await axios.post('https://api.datadoghq.eu/api/v2/incidents', {
      data: {
        type: 'incidents',
        attributes: {
          title: 'Latence élevée sur l'API de paiement',
          severity: 'ERROR',
          customer_impacted: true,
          customer_impact_scope: 'Transactions échouées pour 5% des utilisateurs',
          notification: {
            channelStage: 'declared',
            channelHandle: 'slack'
          }
        },
        relationships: {
          commander: {
            data: {
              type: 'users',
              id: 'user-id'
            }
          }
        }
      }
    }, {
      headers: {
        'Content-Type': 'application/json',
        'DD-API-KEY': process.env.DATADOG_API_KEY,
        'DD-APPLICATION-KEY': process.env.DATADOG_APP_KEY
      }
    });
    
    console.log('Incident créé avec succès:', response.data);
  } catch (error) {
    console.error('Erreur lors de la création de l'incident:', error);
  }
}

Infrastructure as Code avec Terraform

Configuration de moniteurs et de dashboards Datadog avec Terraform :

Configuration Datadog avec Terraform

# Configuration Datadog avec Terraform
provider "datadog" {
  api_key = var.datadog_api_key
  app_key = var.datadog_app_key
  api_url = "https://api.datadoghq.eu/"
}

# Création d'un monitor pour la latence des API
resource "datadog_monitor" "api_latency" {
  name               = "Alerte de latence API"
  type               = "metric alert"
  message            = "La latence moyenne des API dépasse le seuil critique de 500ms.

@slack-team-sre @pagerduty"
  escalation_message = "La latence reste critique depuis plus de 15 minutes, veuillez intervenir rapidement!"

  query = "avg(last_5m):avg:api.response.time{env:production} by {service,endpoint} > 500"

  monitor_thresholds {
    warning  = 300
    critical = 500
  }

  include_tags = true
  
  tags = ["team:platform", "application:api-gateway", "criticality:high"]

  priority = 1
  
  notification_preset_name = "hide_query"
  
  evaluation_delay = 60
}

# Création d'un dashboard
resource "datadog_dashboard" "api_performance" {
  title        = "Performance des API"
  description  = "Dashboard de monitoring des performances des API en production"
  layout_type  = "ordered"

  widget {
    timeseries_definition {
      title = "Temps de réponse moyen par service"
      request {
        q            = "avg:api.response.time{env:production} by {service}"
        display_type = "line"
      }
      yaxis {
        scale = "log"
        include_zero = false
      }
    }
  }

  widget {
    toplist_definition {
      title = "Endpoints les plus lents"
      request {
        q = "top(avg:api.response.time{env:production} by {endpoint}, 10, 'mean', 'desc')"
      }
    }
  }

  widget {
    alert_graph_definition {
      title = "Alertes de latence"
      alert_id = datadog_monitor.api_latency.id
      viz_type = "timeseries"
    }
  }

  widget {
    note_definition {
      content = "### Informations
Ce dashboard montre les métriques de performance des API en production."
      background_color = "gray"
      font_size = "14"
      text_align = "center"
    }
  }

  template_variable {
    name = "service"
    prefix = "service"
    default = "*"
  }

  template_variable {
    name = "endpoint"
    prefix = "endpoint"
    default = "*"
  }
}

Fonctionnalités principales

Infrastructure Monitoring : Surveillance des serveurs, conteneurs, bases de données, services cloud, réseaux, etc.
APM (Application Performance Monitoring) : Suivi des performances au niveau du code, avec traces distribuées et profiling
Log Management : Collecte, traitement et analyse centralisés des logs
Real User Monitoring (RUM) : Analyse des performances front-end et des expériences utilisateurs
Synthetic Monitoring : Tests automatisés simulant des parcours utilisateurs
Network Performance Monitoring : Visibilité sur les performances réseau
Security Monitoring : Détection et investigation des menaces de sécurité
Dashboards : Visualisations personnalisables des métriques et KPIs
Alertes : Notifications configurables sur seuils, anomalies ou forecast
SLOs (Service Level Objectives) : Définition et suivi d'objectifs de niveau de service

Intégrations

Datadog propose plus de 500 intégrations prêtes à l'emploi, notamment avec :

Cloud Providers : AWS, Azure, Google Cloud, IBM Cloud
Conteneurs et Orchestration : Docker, Kubernetes, ECS, EKS, AKS, GKE
Bases de données : MySQL, PostgreSQL, MongoDB, Redis, Elasticsearch
CI/CD : Jenkins, GitHub Actions, GitLab CI, CircleCI
Communication : Slack, Microsoft Teams, PagerDuty, OpsGenie
Frameworks web : Express.js, Django, Rails, Spring Boot

Bonnes pratiques

Tagging cohérent : Utilisez une stratégie de tagging uniforme pour faciliter le filtrage et l'agrégation (env:prod, service:api, team:backend)
Configuration des métriques : Filtrez les métriques non critiques pour réduire les coûts et le bruit
Dashboards hiérarchisés : Créez des dashboards de haut niveau pour la vision globale et des dashboards détaillés pour le debugging
Alertes pertinentes : Configurez des alertes basées sur des impacts utilisateurs réels, avec des seuils appropriés pour éviter les faux positifs
Corrélation : Utilisez les fonctionnalités de corrélation entre métriques, traces et logs pour accélérer le diagnostic
SLOs : Définissez des SLOs réalistes basés sur les attentes des utilisateurs et les capacités techniques
Gestion des accès : Utilisez les RBAC (contrôles d'accès basés sur les rôles) pour limiter l'accès aux données sensibles
Automatisation : Intégrez Datadog dans les pipelines CI/CD pour automatiser les configurations

Applications concrètes

Cas d'usage

Monitoring d'applications microservices

Les architectures microservices sont complexes à surveiller en raison des nombreuses interactions entre services. Datadog excelle dans ce domaine grâce à sa capacité à tracer les requêtes à travers plusieurs services, fournissant une vue complète du parcours d'une transaction.

Optimisation des performances

L'APM Datadog permet d'identifier les goulots d'étranglement dans le code, les requêtes de base de données lentes ou les appels API inefficaces. Ces informations aident les développeurs à optimiser les parties critiques des applications pour une meilleure expérience utilisateur.

Gestion de capacité cloud

Les métriques d'utilisation des ressources cloud (CPU, mémoire, I/O, etc.) collectées par Datadog permettent d'identifier les ressources sous-utilisées ou sur-provisionnées, facilitant l'optimisation des coûts cloud tout en maintenant des performances optimales.

Incidents et war rooms

Lors d'incidents majeurs, les équipes d'ingénierie utilisent les dashboards Datadog comme point central de référence dans leurs "war rooms". La consolidation des métriques, logs et traces accélère considérablement le diagnostic et la résolution des problèmes.