Nouvelles annonces sur les technologies sans serveur et réseau ainsi que sur le RUM (Real-User Monitoring) dévoilées à la conférence Dash ! Nouvelles annonces dévoilées à la conférence Dash !

Référence API

Utilisez l’API HTTP Datadog pour accéder à la plateforme Datadog à l’aide de programmes.

Pour débuter sur l’API HTTP Datadog, utilisez notre collection Postman de Datadog

L’API Datadog utilise des URL orientées ressources, applique des codes de statut afin d’indiquer la réussite ou l’échec des requêtes et renvoie un objet JSON à partir de toutes les requêtes. Rentrons dans le vif du sujet et découvrons son fonctionnement.

Remarque : les exemples de code cURL supposent que vous utilisiez les coreutils GNU et BASH. Sous macOS, vous pouvez installer coreutils via le gestionnaire de paquets Homebrew : brew install coreutils.

SIGNATURE

De nombreuses bibliothèques client exploitent l’API Datadog.

SIGNATURE

  • Si vous utilisez le site américain de Datadog : https://api.datadoghq.com/api/.
  • Si vous utilisez le site européen de Datadog : https://api.datadoghq.eu/api/.

Authentification

Toutes les requêtes à destination de l’API de Datadog doivent être authentifiées. Les requêtes qui rédigent des données dans Datadog doivent posséder un accès au reporting, qui nécessite une clé d'API. Les requêtes qui lisent des données doivent posséder un accès complet, et ont besoin pour cela d’une clé d'application.

Gérez les clés d’application et d’API de votre compte.

EXEMPLE :

from datadog import initialize, api

options = {'api_key': '<YOUR_API_KEY>',
           'app_key': '<YOUR_APP_KEY>',
           'api_host': 'https://api.datadoghq.com'}

initialize(**options)
require 'rubygems'
require 'dogapi'

dog = Dogapi::Client.new(:api_key => '<YOUR_API_KEY>', :application_key => '<YOUR_APP_KEY>', :endpoint => 'https://api.datadoghq.com')
curl "https://api.datadoghq.com/api/v1/validate" \
    -H "DD-API-KEY: <YOUR_API_KEY>" \
    -H "DD-APPLICATION-KEY: <YOUR_APPLICATION_KEY>"

Réussites et erreurs

L’API Datadog utilise des codes de statut HTTP pour indiquer la réussite ou l’échec d’une requête.

Une erreur indique que le service n’a pas pu gérer votre requête. En plus du code de statut, la réponse peut contenir un objet JSON avec un tableau d’erreurs contenant des messages d’erreur plus détaillés. Remarque : lors de l’utilisation de bibliothèques, certaines erreurs peuvent générer des exceptions plutôt que de renvoyer des objets JSON.

Si le service est capable de traiter votre requête, mais que certains problèmes surviennent (par exemple, en raison de l’utilisation d’une API ou d’une version d’API obsolète), le code de statut HTTP indique que la requête est réussite tandis que le corps de la réponse contient le résultat attendu. En outre, un tableau d’avertissements contient des messages d’avertissement détaillés.

Codes de statut :

  • 200 OK
  • 201 Created
  • 202 Accepted
  • 204 No Content
  • 301 Moved Permanently
  • 304 Not Modified
  • 401 Unauthorized
  • 403 Forbidden
  • 404 Not Found
  • 409 Conflict
  • 413 Payload Too Large
  • 422 Unprocessable
  • 429 Too Many Requests
  • 500 Server Error

Exemple de réponse de type Error :

{ 'errors': [
    'Something bad happened to the server.',
    'Your query made the server very sad.'
  ]
}

Exemple de réponse de type Warning :

{ 'some_thing': ...,
  'some_other_thing': ...,
  'warnings': [
      'This is a deprecated API.'
  ]
}

Limites de débit

Certains endpoints de l’API ont une limite de débit. Lorsque vous dépassez un certain nombre de requêtes dans une certaine période, nous renvoyons une erreur.

Pour les endpoints API à débit limité, nous renvoyons les en-têtes afin que vous puissiez vérifier où vous vous situez par rapport à votre limite. Si vous dépassez votre limite, consultez ces en-têtes pour déterminer à quel moment vous pourrez renvoyer ces données.

Les limites de débit peuvent être augmentées par rapport aux valeurs par défaut en contactant l’assistance Datadog.

À propos de la politique sur les limites de débit de l’API :

  • Datadog n’applique pas de limites de débit lors de l’envoi de points de données/métriques (consultez la section sur les métriques pour en savoir plus sur le traitement du débit d’envoi de métrique). Les limites appliquées dépendent de la quantité de métriques custom incluses dans votre abonnement.
  • La limite de débit pour la récupération de métriques est de 100 par heure et par organisation.
  • La limite de débit pour l’envoi d’événements est de 1000 par agrégat, par jour et par organisation. Un agrégat désigne un groupe d’événements similaires.
  • La limite de débit pour les appels query_batch API et Log Query API est de 300 par heure et par organisation. Elle peut être augmentée sur demande.
  • La limite de débit pour l’appel graph_snapshot API est de 60 par heure et par organisation. Elle peut être augmentée sur demande.
  • La limite de débit pour Log Configuration API est de 6000 par minute et par organisation. Elle peut être augmentée sur demande.

En-têtes des limites de débit :

  • X-RateLimit-Limit : nombre de requêtes autorisées sur une période donnée
  • X-RateLimit-Period : durée en secondes pour les réinitialisations (alignées sur le calendrier)
  • X-RateLimit-Remaining : nombre de requêtes autorisées restantes pour la période en cours
  • X-RateLimit-Reset : délai en secondes avant la prochaine réinitialisation

Dépannage

Seule une vérification très minimale des erreurs est effectuée pour le côté frontal de l’API, car toutes les données sont mises en file d’attente afin de les traiter de façon asynchrone (l’objectif étant de toujours accepter vos données en situation de production et de dissocier les systèmes Datadog des vôtres).

Ainsi, il est possible que vous receviez une « réussite » 202, mais que vos données n’apparaissent pas dans Datadog. Ce problème survient probablement à cause d’un des points suivants :

  • Le timestamp est erroné (il n’est pas exprimé en secondes, correspond à une date antérieure, etc.).
  • Vous utilisez une clé d’application au lieu d’une clé d’API
  • Les événements se produisent, mais comme les réussites d’événement ont une faible priorité, elles n’apparaissent pas dans le flux d’événements tant que la priorité « all » ne leur est pas attribuée.

Pour vérifier que votre timestamp est exécuté correctement :

date -u && curl -s -v https://app.datadoghq.com 2>&1 | grep -i '< date'

Cette commande récupère la date actuelle du système, puis envoie une requête à l’endpoint d’une API pour récupérer la date du côté de Datadog. Si l’écart entre les deux dates est supérieur à quelques minutes, nous vous conseillons de vérifier les paramètres de date/heure sur votre serveur.

Certains champs ne sont pas obligatoires pour la requête, mais nécessitent une entrée valide. Par exemple, lorsque vous soumettez un événement, le champ priority doit avoir pour valeur l’une des quatre options données.

Tout autre texte renvoie une « réussite » 202, mais aucun événement n’apparaît. Un source_type_name non valide n’empêche pas l’événement d’apparaître, mais ce champ est supprimé lors de la soumission.

Remarque : les clés de l’API Datadog sont sensibles à la casse. Tous vos attributs JSON pour les endpoints POST doivent être en minuscule.

Checks de service

L’endpoint check de service vous permet d’envoyer des statuts de check afin de les utiliser avec des monitors.

Les messages de check de service ne peuvent pas dépasser 500 caractères. Si un check est envoyé avec un message contenant plus de 500 caractères, seuls les 500 premiers caractères seront affichés.

Envoyer le résultat d’un check

ARGUMENTS:

  • check *[obligatoire]* : le texte du message.

  • host_name *[obligatoire]* : le nom du host qui soumet le check.

  • status *[obligatoire]* : l’entier du statut du check :

    • 0 : OK
    • 1 : WARNING
    • 2 : CRITICAL
    • 3 : UNKNOWN
  • tags *[obligatoire]* : la liste des tags key:val pour ce check.

  • timestamp *[facultatif]* : timestamp POSIX de l’événement.

  • message *[facultatif]* : une description de la raison pour laquelle ce statut est généré.

SIGNATURE:

POST /v1/check_run

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
from datadog.api.constants import CheckStatus

options = {'api_key': '<YOUR_API_KEY>',
           'app_key': '<YOUR_APP_KEY>'}

initialize(**options)

check = 'app.ok'
host = 'app1'
status = CheckStatus.OK  # equals 0
tags = ['env:test']

api.ServiceCheck.check(check=check, host_name=host, status=status, message='Response: 200 OK', tags=tags)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# submitting a check doesn't require an app_key
dog = Dogapi::Client.new(api_key)

dog.service_check('app.is_ok', 'app1', 0, :message => 'Response: 200 OK', :tags => ['env:test'])
currenttime=$(date +%s)

curl  -X POST -H "Content-type: application/json" \
-d "{
      \"check\": \"app.is_ok\",
      \"host_name\": \"app1\",
      \"timestamp\": $currenttime,
      \"status\": 0,
      \"tags\": [\"env:test\"]
}" \
"https://api.datadoghq.com/api/v1/check_run?api_key=<YOUR_API_KEY>"

EXEMPLE DE RÉPONSE:

{
    'status': 'ok'
}
["202", {
    "status" => "ok"
}]

{
  "status": "ok"
}

Commentaires

Les discussions sur Datadog se font via les commentaires. Découvrez comment créer, modifier et supprimer des commentaires et comment y répondre.

Créer un commentaire

Les commentaires sont fondamentalement des événements spéciaux qui apparaissent dans le flux d’événements. Ils peuvent débuter un nouveau fil de discussion ou encore fournir une réponse dans un autre fil.

ARGUMENTS
  • message [obligatoire] :
    Le texte du commentaire.

  • handle [facultatif, défaut=application key owner] : Le handle de l’utilisateur qui publie le commentaire.

  • related_event_id [facultatif, défaut=None] : L’ID d’un autre commentaire ou événement auquel répondre.

SIGNATURE:

POST /v1/comments

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Start a new discussion.
# Include a handle like this
api.Comment.create(
    handle='matt@example.com',
    message='Should we use COBOL or Fortran!'
)

# Or set it to None
# and the handle defaults
# to the owner of the application key
api.Comment.create(message='Should we use COBOL or Fortran?')

# Reply to a discussion.
api.Comment.create(
    handle='joe@example.com',
    message='Smalltalk?',
    related_event_id=1234
)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Make a comment.
dog.comment("I have something to say.")
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl  -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "message" : "There is a problem with the database."
}' \
"https://api.datadoghq.com/api/v1/comments"

EXEMPLE DE RÉPONSE:

{
    'comment': {
        'handle': 'matt@example.com',
        'id': 2603645287324504065,
        'message': 'Should we use COBOL or Fortran?',
        'resource': '/api/v1/comments/2603645287324504065',
        'url': '/event/jump_to?event_id=2603645287324504065'
    }
}
["200", {
    "comment" => {
        "url" => "/event/jump_to?event_id=1382579089039712607",
        "resource" => "/api/v1/comments/1382579089039712607",
        "message" => "I have something to say.",
        "handle" => "mattp+org-carlotest141@datadoghq.com",
        "id" => 1382579089039712607
    }
}]
{
  "comment": {
    "handle": "mattp+org-carlotest141@datadoghq.com",
    "id": 1382561676571697516,
    "message": "There is a problem with the database.",
    "resource": "/api/v1/comments/1382561676571697516",
    "url": "/event/jump_to?event_id=1382561676571697516"
  }
}

Modifier un commentaire

ARGUMENTS
  • message [facultatif, défaut=original message] : Le texte du commentaire.

  • handle [facultatif, défaut=Application key owner] : Le handle de l’utilisateur qui publie le commentaire.

SIGNATURE:

PUT /v1/comments/<ID_COMMENTAIRE>

from datadog import initialize, api
from time import sleep

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Edit a comment.
newcomment = api.Comment.create(
    message='Should we use COBOL or Fortran or Widgets?'
)

sleep(1)

api.Comment.update(
    newcomment['comment']['id'],
    message='I think differently now!'
)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
comment_id = "1382579089039712607"

dog = Dogapi::Client.new(api_key, app_key)

# Update a comment.
dog.update_comment(comment_id, :message => "I've changed my mind again")
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
comment_id=<COMMENT_ID>

# Create a comment to edit. Use jq (http://stedolan.github.io/jq/download/) to get the comment id.
comment_id=$(curl -X POST -H "Content-type: application/json" -H "DD-API-KEY: ${api_key}" -H "DD-APPLICATION-KEY: ${app_key}" -d '{"message" : "This comment was submitted and will be edited by the api."}' "https://api.datadoghq.com/api/v1/comments}" | jq -r '.comment.resource|ltrimstr("/api/v1/comments/")')

curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "message" : "Actually, I am changing my mind."
}' \
"https://api.datadoghq.com/api/v1/comments/${comment_id}"

EXEMPLE DE RÉPONSE:

{
    'comment': {
        'handle': 'matt@example.com',
        'id': 2603645287324504065,
        'message': 'I think differently now.',
        'resource': '/api/v1/comments/2603645287324504065',
        'url': '/event/jump_to?event_id=2603645287324504065'
    }
}
["200", {
    "comment" => {
        "url" => "/event/jump_to?event_id=1382579089039712607",
        "resource" => "/api/v1/comments/1382579089039712607",
        "message" => "I've changed my mind again",
        "handle" => "mattp+org-carlotest141@datadoghq.com",
        "id" => 1382579089039712607
    }
}]
{
  "comment": {
    "handle": "mattp+org-carlotest141@datadoghq.com",
    "id": 1382557387240472966,
    "message": "Actually, I am changing my mind.",
    "resource": "/api/v1/comments/1382557387240472966",
    "url": "/event/jump_to?event_id=1382557387240472966"
  }
}

Dashboards

Ce nouveau endpoint consolide les API screenboard et timeboard pour vous permettre de gérer tous vos dashboards en utilisant un seul format. La documentation relative aux anciens endpoints se trouve ici :

Cet endpoint vous permet de programmer la création, la mise à jour, la suppression et la récupération de dashboards.

Créer un dashboard

ARGUMENTS:

  • title [obligatoire] : Titre du dashboard.
  • widgets [obligatoire] : Liste des widgets à afficher sur le dashboard. Les définitions de widget respectent le format suivant :
    • definition [obligatoire] : Définition du widget.
    • id [facultatif, valeur par défaut=entier généré automatiquement] : ID du widget.
    • layout [obligatoire pour les widgets de dashboard dont le layout_type est free uniquement]. La structure de la disposition respecte le format suivant :
      • x [obligatoire] La position du widget sur l’axe des abscisses (X). Doit être un entier non négatif.
      • y [obligatoire] La position du widget sur l’axe des ordonnées (Y). Doit être un entier non négatif.
      • width [obligatoire] La largeur du widget. Doit être un entier non négatif.
      • height [obligatoire] La hauteur du widget. Doit être un entier non négatif.
  • layout_type [obligatoire] : Type de disposition du dashboard. Valeurs possibles : ordered (timeboard précédent) ou free (disposition du screenboard précédent)
  • description [facultatif, défaut=None] : Description du dashboard.
  • is_read_only [facultatif, défaut=False] : Définit si ce dashboard est en lecture seule. Si True, seul l’auteur et les administrateurs peuvent effectuer des modifications.
  • notify_list [facultatif, défaut=None] : Liste des handles des utilisateurs à notifier lorsque des changements sont apportés à ce dashboard.
  • template_variables [facultatif, défaut=None] : Liste des template variables pour ce dashboard. Les définitions de template variables respectent le format suivant :
    • name [obligatoire] : Nom de la variable.
    • default [facultatif, défaut=None] : la valeur par défaut de la template variable lors du chargement du dashboard.
    • prefix [facultatif, défaut=None] : Préfixe de tag associé à la variable. Seuls les tags avec ce préfixe apparaissent dans la liste déroulante des variables.

SIGNATURE:

POST /v1/dashboard

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

title = 'Average Memory Free Shell'
widgets = [{
    'definition': {
        'type': 'timeseries',
        'requests': [
            {'q': 'avg:system.mem.free{*}'}
        ],
        'title': 'Average Memory Free'
    }
}]
layout_type = 'ordered'
description = 'A dashboard with memory info.'
is_read_only = True
notify_list = ['user@domain.com']
template_variables = [{
    'name': 'host1',
    'prefix': 'host',
    'default': 'my-host'
}]
api.Dashboard.create(title=title,
                     widgets=widgets,
                     layout_type=layout_type,
                     description=description,
                     is_read_only=is_read_only,
                     notify_list=notify_list,
                     template_variables=template_variables)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Create a dashboard.
title = 'Average Memory Free Shell'
widgets = [{
    'definition': {
        'type' => 'timeseries',
        'requests' => [
            {'q' => 'avg:system.mem.free{*}'}
        ],
        'title' => 'Average Memory Free'
    }
}]
layout_type = 'ordered'
description = 'A dashboard with memory info.'
is_read_only = true
notify_list = ['user@domain.com']
template_variables = [{
    'name' => 'host1',
    'prefix' => 'host',
    'default' => 'my-host'
}]

dog.create_board(title, widgets, layout_type, {
    'description' => description,
    'is_read_only' => is_read_only,
    'notify_list' => notify_list,
    'template_variables' => template_variables
    })
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl  -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "title" : "Average Memory Free Shell",
      "widgets" : [{
          "definition": {
              "type": "timeseries",
              "requests": [
                  {"q": "avg:system.mem.free{*}"}
              ],
              "title": "Average Memory Free"
          }
      }],
      "layout_type": "ordered",
      "description" : "A dashboard with memory info.",
      "is_read_only": true,
      "notify_list": ["user@domain.com"],
      "template_variables": [{
          "name": "host1",
          "prefix": "host",
          "default": "my-host"
      }]
}' \
"https://api.datadoghq.com/api/v1/dashboard"

EXEMPLE DE RÉPONSE:

{
   'notify_list':[
        'user@domain.com'
   ],
   'description':'A dashboard with memory info.',
   'template_variables':[
      {
         'default':'my-host',
         'prefix':'host',
         'name':'host1'
      }
   ],
   'is_read_only':True,
   'id':'qc9-tuk-9kv',
   'title':'Average Memory Free Shell',
   'url':'/dashboard/qc9-tuk-9kv/average-memory-free-shell',
   'created_at':'2019-02-05T01:20:56.323548+00:00',
   'modified_at':'2019-02-05T01:20:56.323548+00:00',
   'author_handle':'user@domain.com',
   'widgets':[
      {
         'definition':{
            'requests':[
               {
                  'q':'avg:system.mem.free{*}'
               }
            ],
            'type':'timeseries',
            'title':'Average Memory Free'
         },
         'id':2252428653625902
      }
   ],
   'layout_type':'ordered'
}
[
   "200",
   {
      "notify_list" => ["user@domain.com"],
      "description" => nil,
      "template_variables" => nil,
      "is_read_only" => true,
      "id" => "qc9-tuk-9kv",
      "title" => "Average Memory Free Shell",
      "url" => "/dashboard/qc9-tuk-9kv/average-memory-free-shell",
      "created_at" => "2019-02-05T01:35:46.388000+00:00",
      "modified_at" => "2019-02-05T01:35:46.388000+00:00",
      "author_handle" => "user@domain.com",
      "widgets" => [
         {
            "definition" => {
               "requests" => [
                   { "q" => "avg:system.mem.free{*}"}
               ],
               "type" => "timeseries",
               "title" => "Average Memory Free"
            },
            "id" => 2252428653625902
         }
      ],
      "layout_type" => "ordered"
   }
]
{
    "notify_list": [
        "user@domain.com"
    ],
    "description": "A dashboard with memory info.",
    "template_variables": [
        {
            "default": "my-host",
            "prefix": "host",
            "name": "host1"
        }
    ],
    "is_read_only": true,
    "id": "qc9-tuk-9kv",
    "title": "Average Memory Free Shell",
    "url": "/dashboard/qc9-tuk-9kv/average-memory-free-shell",
    "created_at": "2019-02-05T01:06:36.636295+00:00",
    "modified_at": "2019-02-05T01:06:36.636295+00:00",
    "author_handle": "user@domain.com",
    "widgets": [
        {
            "definition": {
                "requests": [
                    {
                        "q": "avg:system.mem.free{*}"
                    }
                ],
                "type": "timeseries",
                "title": "Average Memory Free"
            },
            "id": 2252428653625902
        }
    ],
    "layout_type": "ordered"
}

Mettre à jour un dashboard

ARGUMENTS:

  • title [obligatoire] : Titre du dashboard.
  • widgets [obligatoire] : Liste des widgets à afficher sur le dashboard. Les définitions de widget respectent le format suivant :
    • definition [obligatoire] : Définition du widget.
    • id [facultatif, défaut=entier généré automatiquement] : ID du widget.
    • layout [obligatoire pour les widgets de dashboard dont le layout_type est free uniquement]. La structure de la disposition respecte le format suivant :
      • x [obligatoire] La position du widget sur l’axe des abscisses (X). Doit être un entier non négatif.
      • y [obligatoire] La position du widget sur l’axe des ordonnées (Y). Doit être un entier non négatif.
      • width [obligatoire] La largeur du widget. Doit être un entier non négatif.
      • height [obligatoire] La hauteur du widget. Doit être un entier non négatif.
  • layout_type [obligatoire] : Type de disposition du dashboard. Valeurs possibles : ordered (timeboard précédent) ou free (disposition du screenboard précédent)
  • description [facultatif, défaut=None] : Description du dashboard.
  • is_read_only [facultatif, défaut=False] : Définit si ce dashboard est en lecture seule. Si True, seul l’auteur et les administrateurs peuvent effectuer des modifications.
  • notify_list [facultatif, défaut=None] : Liste des handles des utilisateurs à notifier lorsque des changements sont apportés à ce dashboard.
  • template_variables [facultatif, défaut=None] : Liste des template variables pour ce dashboard. Les définitions de template variables respectent le format suivant :
    • name [obligatoire] : Nom de la variable.
    • default [facultatif, défaut=None] : la valeur par défaut de la template variable lors du chargement du dashboard.
    • prefix [facultatif, défaut=None] : Préfixe de tag associé à la variable. Seuls les tags avec ce préfixe apparaissent dans la liste déroulante des variables.

SIGNATURE:

PUT /v1/dashboard/<ID_DASHBOARD>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {'api_key': '<YOUR_API_KEY>',
           'app_key': '<YOUR_APP_KEY>'}

initialize(**options)

dashboard_id = '<DASHBOARD_ID>'

title = 'Sum of Memory Free'
widgets = [{
    'definition': {
        'type': 'timeseries',
        'requests': [
            {'q': 'sum:system.mem.free{*}'}
        ],
        'title': 'Sum Memory Free Shell'
    }
}]
layout_type = 'ordered'
description = 'An updated dashboard with memory info.'
is_read_only = True
notify_list = ['user@domain.com']
template_variables = [{
    'name': 'host1',
    'prefix': 'host',
    'default': 'my-host'
}]
api.Dashboard.update(dashboard_id,
                     title=title,
                     widgets=widgets,
                     layout_type=layout_type,
                     description=description,
                     is_read_only=is_read_only,
                     notify_list=notify_list,
                     template_variables=template_variables)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dashboard_id = '<DASHBOARD_ID>'

title = 'Sum of Memory Free'
widgets = [{
    'definition': {
        'type' => 'timeseries',
        'requests' => [
            {'q' => 'sum:system.mem.free{*}'}
        ],
        'title' => 'Sum Memory Free Shell'
    }
}]
layout_type = 'ordered'
description = 'An updated dashboard with memory info.'
is_read_only = true
notify_list = ['user@domain.com']
template_variables = [{
    'name' => 'host1',
    'prefix' => 'host',
    'default' => 'my-host'
}]

dog.update_board(dashboard_id, title, widgets, layout_type, {
    'description' => description,
    'is_read_only' => is_read_only,
    'notify_list' => notify_list,
    'template_variables' => template_variables
    })
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
dashboard_id="<DASHBOARD_ID>"

curl  -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "title" : "Sum of Memory Free",
      "widgets" : [{
          "definition": {
              "type": "timeseries",
              "requests": [
                  {"q": "sum:system.mem.free{*}"}
              ],
              "title": "Sum Memory Free Shell"
          }
      }],
      "layout_type": "ordered",
      "description" : "An updated dashboard with memory info.",
      "is_read_only": true,
      "notify_list": ["user@domain.com"],
      "template_variables": [{
          "name": "host1",
          "prefix": "host",
          "default": "my-host"
      }]
}' \
"https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}"

EXEMPLE DE RÉPONSE:

{
   'notify_list':[
        'user@domain.com'
   ],
   'description':'An updated dashboard with memory info.',
   'template_variables':[
      {
         'default':'my-host',
         'prefix':'host',
         'name':'host1'
      }
   ],
   'is_read_only':True,
   'id':'qc9-tuk-9kv',
   'title':'Sum of Memory Free',
   'url':'/dashboard/qc9-tuk-9kv/sum-of-memory-free',
   'created_at':'2019-02-05T01:06:36.636295+00:00',
   'modified_at':'2019-02-05T02:14:15.769022+00:00',
   'author_handle':'user@domain.com',
   'widgets':[
      {
         'definition':{
            'requests':[
               {
                  'q':'sum:system.mem.free{*}'
               }
            ],
            'type':'timeseries',
            'title':'Sum Memory Free Shell'
         },
         'id':6744688099018785
      }
   ],
   'layout_type':'ordered'
}
[
   "200",
   {
      "notify_list" => ["user@domain.com"],
      "description" => nil,
      "template_variables" => nil,
      "is_read_only" => false,
      "id" => "qc9-tuk-9kv",
      "title" => "Sum of Memory Free",
      "url" => "/dashboard/qc9-tuk-9kv/sum-of-memory-free",
      "created_at" => "2019-02-05T01:06:36.636295+00:00",
      "modified_at" => "2019-02-05T02:19:06.792555+00:00",
      "author_handle" => "user@domain.com",
      "widgets" => [
         {
            "definition" => {
               "requests" => [
                  {
                     "q" => "sum:system.mem.free{*}"
                  }
               ],
               "type" => "timeseries",
               "title" => "Sum Memory Free Shell"
            },
            "id" => 7763291144447019
         }
      ],
      "layout_type" => "ordered"
   }
]
{
    "notify_list": ["user@domain.com"],
    "description": "An updated dashboard with memory info.",
    "template_variables": [
        {
            "default": "my-host",
            "prefix": "host",
            "name": "host1"
        }
    ],
    "is_read_only": true,
    "id": "qc9-tuk-9kv",
    "title": "Sum of Memory Free",
    "url": "/dashboard/qc9-tuk-9kv/sum-of-memory-free",
    "created_at": "2019-02-05T01:06:36.636295+00:00",
    "modified_at": "2019-02-05T02:08:57.399410+00:00",
    "author_handle": "user@domain.com",
    "widgets": [
        {
            "definition": {
                "requests": [
                    {
                        "q": "sum:system.mem.free{*}"
                    }
                ],
                "type": "timeseries",
                "title": "Sum Memory Free Shell"
            },
            "id": 6979333833881176
        }
    ],
    "layout_type": "ordered"
}

Supprimer un dashboard

Supprimer un dashboard existant.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

DELETE /v1/dashboard/<ID_DASHBOARD>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

dashboard_id = '<DASHBOARD_ID>'

api.Dashboard.delete(dashboard_id)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dashboard_id = '<DASHBOARD_ID>'
dog.delete_board(dashboard_id)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
dashboard_id="<DASHBOARD_ID>"

curl -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}"

EXEMPLE DE RÉPONSE:

{
    'deleted_dashboard_id': 'qc9-tuk-9kv'
}
["200", {"deleted_dashboard_id" => "qc9-tuk-9kv"}]
{
    "deleted_dashboard_id": "qc9-tuk-9kv"
}

Obtenir un dashboard

Récupérez la définition d’un dashboard existant.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/dashboard/<ID_DASHBOARD>

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

dashboard_id = '<DASHBOARD_ID>'

api.Dashboard.get(dashboard_id)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dashboard_id = '<DASHBOARD_ID>'
dog.get_board(dashboard_id)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
dashboard_id="<DASHBOARD_ID>"

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}"

EXEMPLE DE RÉPONSE :

{
   'notify_list':[
        'user@domain.com'
   ],
   'description':'A dashboard with memory info.',
   'template_variables':[
      {
         'default':'my-host',
         'prefix':'host',
         'name':'host1'
      }
   ],
   'is_read_only':True,
   'id':'qc9-tuk-9kv',
   'title':'Average Memory Free Shell',
   'url':'/dashboard/qc9-tuk-9kv/average-memory-free-shell',
   'created_at':'2019-02-05T01:20:56.323548+00:00',
   'modified_at':'2019-02-05T01:20:56.323548+00:00',
   'author_handle':'user@domain.com',
   'widgets':[
      {
         'definition':{
            'requests':[
               {
                  'q':'avg:system.mem.free{*}'
               }
            ],
            'type':'timeseries',
            'title':'Average Memory Free'
         },
         'id':2252428653625902
      }
   ],
   'layout_type':'ordered'
}
{
    "notify_list": [
        "user@domain.com"
    ],
    "description": "A dashboard with memory info.",
    "template_variables": [
        {
            "default": "my-host",
            "prefix": "host",
            "name": "host1"
        }
    ],
    "is_read_only": true,
    "id": "qc9-tuk-9kv",
    "title": "Average Memory Free Shell",
    "url": "/dashboard/qc9-tuk-9kv/average-memory-free-shell",
    "created_at": "2019-02-05T01:06:36.636295+00:00",
    "modified_at": "2019-02-05T01:06:36.636295+00:00",
    "author_handle": "user@domain.com",
    "widgets": [
        {
            "definition": {
                "requests": [
                    {
                        "q": "avg:system.mem.free{*}"
                    }
                ],
                "type": "timeseries",
                "title": "Average Memory Free"
            },
            "id": 2252428653625902
        }
    ],
    "layout_type": "ordered"
}
{
    "notify_list": [
        "user@domain.com"
    ],
    "description": "A dashboard with memory info.",
    "template_variables": [
        {
            "default": "my-host",
            "prefix": "host",
            "name": "host1"
        }
    ],
    "is_read_only": true,
    "id": "qc9-tuk-9kv",
    "title": "Average Memory Free Shell",
    "url": "/dashboard/qc9-tuk-9kv/average-memory-free-shell",
    "created_at": "2019-02-05T01:06:36.636295+00:00",
    "modified_at": "2019-02-05T01:06:36.636295+00:00",
    "author_handle": "user@domain.com",
    "widgets": [
        {
            "definition": {
                "requests": [
                    {
                        "q": "avg:system.mem.free{*}"
                    }
                ],
                "type": "timeseries",
                "title": "Average Memory Free"
            },
            "id": 2252428653625902
        }
    ],
    "layout_type": "ordered"
}

Obtenir tous les dashboards

Récupérer tous les dashboards.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/dashboard

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

api.Dashboard.get_all()
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.get_all_boards()
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard"

EXEMPLE DE RÉPONSE:

{
  'dashboards': [{
      'created_at': '2019-02-28T17:12:59.327729+00:00',
      'is_read_only': False,
      'description': 'My Screenboard Description',
      'title': 'My Screenboard',
      'url': '/dashboard/grh-zkj-h2c/my-screenboard',
      'layout_type': 'free',
      'modified_at': '2019-03-13T19:09:40.930616+00:00',
      'author_handle':'user@domain.com',
      'id': 'grh-zkj-h2c'
    },
    {
      'created_at': '2019-02-28T17:45:11.535045+00:00',
      'is_read_only': False,
      'description': 'My Timeboard Description',
      'title': 'My Timeboard',
      'url': '/dashboard/4qf-77b-uhc/my-timeboard',
      'layout_type': 'ordered',
      'modified_at': '2019-03-11T14:22:03.131495+00:00',
      'author_handle':'user@domain.com',
      'id': '4qf-77b-uhc'
    }
  ]
}
{
  "dashboards": [{
    "created_at" => "2019-02-28T17:12:59.327729+00:00",
    "is_read_only" => false,
    "description" => "My Screenboard Description",
    "title" => "My Screenboard",
    "url" => "/dashboard/grh-zkj-h2c/my-screenboard",
    "layout_type" => "free",
    "modified_at" => "2019-03-13T19:09:40.930616+00:00",
    "author_handle": "user@domain.com",
    "id" => "grh-zkj-h2c"
  }, {
    "created_at" => "2019-02-28T17:45:11.535045+00:00",
    "is_read_only" => false,
    "description" => "My Timeboard Description",
    "title" => "My Timeboard",
    "url" => "/dashboard/4qf-77b-uhc/my-timeboard",
    "layout_type" => "ordered",
    "modified_at" => "2019-03-11T14:22:03.131495+00:00",
    "author_handle": "user@domain.com",
    "id" => "4qf-77b-uhc"
  }]
}
{
  "dashboards": [{
      "created_at": "2019-02-28T17:12:59.327729+00:00",
      "is_read_only": false,
      "description": "My Screenboard Description",
      "title": "My Screenboard",
      "url": "/dashboard/grh-zkj-h2c/my-screenboard",
      "layout_type": "free",
      "modified_at": "2019-03-13T19:09:40.930616+00:00",
      "author_handle": "user@domain.com",
      "id": "grh-zkj-h2c"
    },
    {
      "created_at": "2019-02-28T17:45:11.535045+00:00",
      "is_read_only": false,
      "description": "My Timeboard Description",
      "title": "My Timeboard",
      "url": "/dashboard/4qf-77b-uhc/my-timeboard",
      "layout_type": "ordered",
      "modified_at": "2019-03-11T14:22:03.131495+00:00",
      "author_handle": "user@domain.com",
      "id": "4qf-77b-uhc"
    }
  ]
}

Listes de dashboards

Interagissez avec vos listes de dashboards via l’API pour faciliter l’organisation, la recherche et le partage de tous vos dashboards avec votre équipe et votre organisation.

Récupérer une liste de dashboards

Récupérez la définition d’une liste de dashboards existant.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/dashboard/lists/manual/<ID_LISTE>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

api.DashboardList.get(4741)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

result = dog.get_dashboard_list(4741)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

list_id=4741

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}"

EXEMPLE DE RÉPONSE:

{
    'name': 'My Dashboard List',
    'created': '2018-03-16T09:44:41.476018+00:00',
    'author': {
        'handle': 'test1@datadoghq.com',
        'name': 'Author Name'
    },
    'dashboards': None,
    'modified': '2018-03-16T09:44:41.476030+00:00',
    'is_favorite': False,
    'dashboard_count': 0,
    'type': 'manual_dashboard_list',
    'id': 4741
}
[
    "200",
    {
        "is_favorite" => false,
        "name" => "My Dashboard List",
        "dashboard_count" => 0,
        "author" => {
            "handle" => "test1@datadoghq.com",
            "name" => "Author Name"
        },
        "created" => "2018-03-16T09:44:41.476018+00:00",
        "type" => "manual_dashboard_list",
        "dashboards" => nil,
        "modified" => "2018-03-16T09:44:41.476030+00:00",
        "id" => 4741
    }
]
{
    "name": "My Dashboard List",
    "created": "2018-03-16T09:44:41.476018+00:00",
    "author": {
        "handle": "test1@datadoghq.com",
        "name": "Author Name"
    },
    "dashboards": None,
    "modified": "2018-03-16T09:44:41.476030+00:00",
    "is_favorite": False,
    "dashboard_count": 0,
    "type": "manual_dashboard_list",
    "id": 4741
}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Get all Dashboard Lists

Fetch all of your existing dashboard list definitions.

ARGUMENTS:

This endpoint takes no JSON arguments.

SIGNATURE:

GET /v1/dashboard/lists/manual

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

api.DashboardList.get_all()
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

result = dog.get_all_dashboard_lists()
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual"

EXEMPLE DE RÉPONSE:

{
    'dashboard_lists': [
        {
            'name': 'My Dashboard List B',
            'created': '2017-09-14T14:59:59.040891+00:00',
            'author': {
                'handle': 'test1@datadoghq.com',
                'name': 'Author Name'
            },
            'dashboards': None,
            'modified': '2018-03-16T13:03:52.698416+00:00',
            'is_favorite': True,
            'dashboard_count': 22,
            'type': 'manual_dashboard_list',
            'id': 142
        },
        {
            'name': 'My Dashboard List A',
            'created': '2017-11-17T11:17:43.273931+00:00',
            'author': {
                'handle': 'test2@datadoghq.com',
                'name': 'Other Author Name'
            },
            'dashboards': None,
            'modified': '2018-03-16T13:03:43.835281+00:00',
            'is_favorite': False,
            'dashboard_count': 12,
            'type': 'manual_dashboard_list',
            'id': 295
        }
    ]
}
[
    "200",
    {
        "dashboard_lists" => [
            {
                "is_favorite" => true,
                "name" => "My Dashboard List B",
                "dashboard_count" => 22,
                "author" => {
                    "handle" => "test1@datadoghq.com",
                    "name" => "Author Name"
                },
                "created" => "2017-09-14T14:59:59.040891+00:00",
                "type" => "manual_dashboard_list",
                "dashboards" => nil,
                "modified" => "2018-03-16T13:03:52.698416+00:00",
                "id" => 142
            },
            {
                "is_favorite" => false,
                "name" => "My Dashboard List A",
                "dashboard_count" => 12,
                "author" => {
                    "handle" => "test2@datadoghq.com",
                    "name" => "Other Author Name"
                },
                "created" => "2017-11-17T11:17:43.273931+00:00",
                "type" => "manual_dashboard_list",
                "dashboards" => nil,
                "modified" => "2018-03-16T13:03:43.835281+00:00",
                "id" => 295
            }
        ]
    }
]
{
    "dashboard_lists": [
        {
            "name": "My Dashboard List B",
            "created": "2017-09-14T14:59:59.040891+00:00",
            "author": {
                "handle": "test1@datadoghq.com",
                "name": "Author Name"
            },
            "dashboards": None,
            "modified": "2018-03-16T13:03:52.698416+00:00",
            "is_favorite": True,
            "dashboard_count": 22,
            "type": "manual_dashboard_list",
            "id": 142
        },
        {
            "name": "My Dashboard List A",
            "created": "2017-11-17T11:17:43.273931+00:00",
            "author": {
                "handle": "test2@datadoghq.com",
                "name": "Other Author Name"
            },
            "dashboards": None,
            "modified": "2018-03-16T13:03:43.835281+00:00",
            "is_favorite": False,
            "dashboard_count": 12,
            "type": "manual_dashboard_list",
            "id": 295
        }
    ]
}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Create a Dashboard List

Create an empty dashboard list.

ARGUMENTS:

  • name [required]: The name of the dashboard list.

SIGNATURE:

POST /v1/dashboard/lists/manual

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

name = 'My Dashboard List'

api.DashboardList.create(name=name)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

name = 'My Dashboard List'

result = dog.create_dashboard_list(name)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "name": "My Dashboard List"
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual"

EXEMPLE DE RÉPONSE:

{
    'name': 'My Dashboard List',
    'created': '2018-03-16T09:44:41.476018+00:00',
    'author': {
        'handle': 'test1@datadoghq.com',
        'name': 'Author Name'
    },
    'dashboards': None,
    'modified': '2018-03-16T09:44:41.476030+00:00',
    'is_favorite': False,
    'dashboard_count': 0,
    'type': 'manual_dashboard_list',
    'id': 4741
}
[
    "200",
    {
        "is_favorite" => false,
        "name" => "My Dashboard List",
        "dashboard_count" => 0,
        "author" => {
            "handle" => "test1@datadoghq.com",
            "name" => "Author Name"
        },
        "created" => "2018-03-16T09:51:47.905261+00:00",
        "type" => "manual_dashboard_list",
        "dashboards" => nil,
        "modified" => "2018-03-16T09:51:47.905273+00:00",
        "id" => 4741
    }
]
{
    "name": "My Dashboard List",
    "created": "2018-03-16T09:44:41.476018+00:00",
    "author": {
        "handle": "test1@datadoghq.com",
        "name": "Author Name"
    },
    "dashboards": None,
    "modified": "2018-03-16T09:44:41.476030+00:00",
    "is_favorite": False,
    "dashboard_count": 0,
    "type": "manual_dashboard_list",
    "id": 4741
}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Update a Dashboard List

Update the name of a dashboard list

ARGUMENTS:

  • name [required]: The name of the dashboard list.

SIGNATURE :

PUT /v1/dashboard/lists/manual/<ID_LISTE>

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

list_id = 4741
name = 'My Updated Dashboard List'

api.DashboardList.update(list_id, name=name)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

list_id = 4741
name = 'My Updated Dashboard List'

result = dog.update_dashboard_list(list_id, name)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

list_id=4741

curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "name": "My Updated Dashboard List"
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}"

EXEMPLE DE RÉPONSE :

{
    'name': 'My Updated Dashboard List',
    'created': '2018-03-16T09:44:41.476018+00:00',
    'author': {
        'handle': 'test1@datadoghq.com',
        'name': 'Author Name'
    },
    'dashboards': None,
    'modified': '2018-03-16T13:45:42.288026+00:00',
    'is_favorite': False,
    'dashboard_count': 5,
    'type': 'manual_dashboard_list',
    'id': 4741
}
[
    "200",
    {
        "is_favorite" => false,
        "name" => "My Updated Dashboard List",
        "dashboard_count" => 5,
        "author" => {
            "handle" => "test1@datadoghq.com",
            "name" => "Author Name"
        },
        "created" => "2018-03-16T09:44:41.476018+00:00",
        "type" => "manual_dashboard_list",
        "dashboards" => nil,
        "modified" => "2018-03-16T13:45:42.288026+00:00",
        "id" => 4741
    }
]
{
    "name": "My Updated Dashboard List",
    "created": "2018-03-16T09:44:41.476018+00:00",
    "author": {
        "handle": "test1@datadoghq.com",
        "name": "Author Name"
    },
    "dashboards": None,
    "modified": "2018-03-16T13:45:42.288026+00:00",
    "is_favorite": False,
    "dashboard_count": 5,
    "type": "manual_dashboard_list",
    "id": 4741
}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Delete a Dashboard List

Delete an existing dashboard list.

ARGUMENTS:

This endpoint takes no JSON arguments.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

DELETE /v1/dashboard/lists/manual/<LIST_ID>

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

api.DashboardList.delete(4741)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

result = dog.delete_dashboard_list(4741)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

list_id=4741

curl -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}"

EXAMPLE RESPONSE:

{
    'deleted_dashboard_list_id': 4741
}
[
    "200",
    {
        "deleted_dashboard_list_id" => 4741
    }
]
{
    "deleted_dashboard_list_id": 4741
}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Get Items of a Dashboard List

Fetch the dashboard list’s dashboard definitions.

This endpoint has been updated to reflect the new Dashboard API changes. Documentation for old endpoint is available here:

ARGUMENTS:

This endpoint takes no JSON arguments.

SIGNATURE:

GET /v2/dashboard/lists/manual/<ID_LISTE>/dashboards

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

api.DashboardList.v2.get_items(4741)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

result = dog.v2.get_items_of_dashboard_list(4741)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

list_id=4741

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v2/dashboard/lists/manual/${list_id}/dashboards"

EXEMPLE DE RÉPONSE:

{
    'total': 5,
    'dashboards': [
        {
            'popularity': 0,
            'is_shared': False,
            'author': {
                'handle': None,
                'name': None
            },
            'url': '/screen/integration/87/aws-dynamodb',
            'title': 'AWS DynamoDB',
            'modified': None,
            'created': None,
            'is_favorite': True,
            'is_read_only': True,
            'type': 'integration_screenboard',
            'id': '87',
            'icon': '/static/v/34.254868/images/saas_logos/small/amazon_dynamodb.png'
        },
        {
            'popularity': 0,
            'is_shared': False,
            'author': {
                'handle': None,
                'name': None
            },
            'url': '/dash/integration/23/postgres---metrics',
            'title': 'Postgres - Metrics',
            'modified': None,
            'created': None,
            'is_favorite': True,
            'is_read_only': True,
            'type': 'integration_timeboard',
            'id': '23',
            'icon': '/static/v/34.254868/images/saas_logos/small/postgres.png'
        },
        {
            'popularity': 0,
            'is_shared': False,
            'author': {
                'handle': 'test1@datadoghq.com',
                'name': 'Author Name'
            },
            'url': '/dashboard/qts-q2k-yq6/trace-api',
            'title': 'Trace API',
            'modified': '2018-03-16T13:39:39.517133+00:00',
            'created': '2015-10-21T13:22:48.633391+00:00',
            'is_favorite': False,
            'is_read_only': False,
            'type': 'custom_timeboard',
            'id': 'qts-q2k-yq6',
            'icon': None
        },
        {
            'popularity': 0,
            'is_shared': False,
            'author': {
                'handle': 'test2@datadoghq.com',
                'name': 'Other Author Name'
            },
            'url': '/dashboard/rys-xwq-geh/agent-stats',
            'title': 'Agent Stats',
            'modified': '2018-03-16T12:54:25.968134+00:00',
            'created': '2014-06-18T18:19:00.974763+00:00',
            'is_favorite': False,
            'is_read_only': False,
            'type': 'custom_screenboard',
            'id': 'rys-xwq-geh',
            'icon': None
        },
        {
            'popularity': 0,
            'is_shared': False,
            'author': {
                'handle': None,
                'name': None
            },
            'url': '/dash/host/3245468',
            'title': 'agent-gui',
            'modified': None,
            'created': None,
            'is_favorite': False,
            'is_read_only': True,
            'type': 'host_timeboard',
            'id': '3245468',
            'icon': None
        }
    ]
}
[
    "200",
    {
        "total" => 5,
        "dashboards" => [
            {
                "popularity" => 0,
                "title" => "AWS DynamoDB",
                "is_favorite" => true,
                "id" => "87",
                "icon" => "/static/v/34.254868/images/saas_logos/small/amazon_dynamodb.png",
                "is_shared" => false,
                "author" => {
                    "handle" => nil,
                    "name" => nil
                },
                "url" => "/screen/integration/87/aws-dynamodb",
                "created" => nil,
                "modified" => nil,
                "is_read_only" => true,
                "type" => "integration_screenboard"
            },
            {
                "popularity" => 0,
                "title" => "Postgres - Metrics",
                "is_favorite" => true,
                "id" => "23",
                "icon" => "/static/v/34.254868/images/saas_logos/small/postgres.png",
                "is_shared" => false,
                "author" => {
                    "handle" => nil,
                    "name" => nil
                },
                "url" => "/dash/integration/23/postgres---metrics",
                "created" => nil,
                "modified" => nil,
                "is_read_only" => true,
                "type" => "integration_timeboard"
            },
            {
                "popularity" => 0,
                "title" => "Trace API",
                "is_favorite" => false,
                "id" => "qts-q2k-yq6",
                "icon" => nil,
                "is_shared" => false,
                "author" => {
                    "handle" => "test1@datadoghq.com",
                    "name" => "Author Name"
                },
                "url" => "/dashboard/qts-q2k-yq6/trace-api",
                "created" => "2015-10-21T13:22:48.633391+00:00",
                "modified" => "2018-03-16T13:39:39.517133+00:00",
                "is_read_only" => false,
                "type" => "custom_timeboard"
            },
            {
                "popularity" => 0,
                "title" => "Agent Stats",
                "is_favorite" => false,
                "id" => "rys-xwq-geh",
                "icon" => nil,
                "is_shared" => false,
                "author" => {
                    "handle" => "test2@datadoghq.com",
                    "name" => "Other Author Name"
                },
                "url" => "/dashboard/rys-xwq-geh/agent-stats",
                "created" => "2014-06-18T18:19:00.974763+00:00",
                "modified" => "2018-03-16T12:54:25.968134+00:00",
                "is_read_only" => false,
                "type" => "custom_screenboard"
            },
            {
                "popularity" => 0,
                "title" => "agent-gui",
                "is_favorite" => false,
                "id" => "3245468",
                "icon" => nil,
                "is_shared" => false,
                "author" => {
                    "handle" => nil,
                    "name" => nil
                },
                "url" => "/dash/host/3245468",
                "created" => nil,
                "modified" => nil,
                "is_read_only" => true,
                "type" => "host_timeboard"
            }
        ]
    }
]
{
    "total": 5,
    "dashboards": [
        {
            "popularity": 0,
            "is_shared": False,
            "author": {
                "handle": None,
                "name": None
            },
            "url": "/screen/integration/87/aws-dynamodb",
            "title": "AWS DynamoDB",
            "modified": None,
            "created": None,
            "is_favorite": True,
            "is_read_only": True,
            "type": "integration_screenboard",
            "id": "87",
            "icon": "/static/v/34.254868/images/saas_logos/small/amazon_dynamodb.png"
        },
        {
            "popularity": 0,
            "is_shared": False,
            "author": {
                "handle": None,
                "name": None
            },
            "url": "/dash/integration/23/postgres---metrics",
            "title": "Postgres - Metrics",
            "modified": None,
            "created": None,
            "is_favorite": True,
            "is_read_only": True,
            "type": "integration_timeboard",
            "id": "23",
            "icon": "/static/v/34.254868/images/saas_logos/small/postgres.png"
        },
        {
            "popularity": 0,
            "is_shared": False,
            "author": {
                "handle": "test1@datadoghq.com",
                "name": "Author Name"
            },
            "url": "/dashboard/qts-q2k-yq6/trace-api",
            "title": "Trace API",
            "modified": "2018-03-16T13:39:39.517133+00:00",
            "created": "2015-10-21T13:22:48.633391+00:00",
            "is_favorite": False,
            "is_read_only": False,
            "type": "custom_timeboard",
            "id": "qts-q2k-yq6",
            "icon": None
        },
        {
            "popularity": 0,
            "is_shared": False,
            "author": {
                "handle": "test2@datadoghq.com",
                "name": "Other Author Name"
            },
            "url": "/dashboard/rys-xwq-geh/agent-stats",
            "title": "Agent Stats",
            "modified": "2018-03-16T12:54:25.968134+00:00",
            "created": "2014-06-18T18:19:00.974763+00:00",
            "is_favorite": False,
            "is_read_only": False,
            "type": "custom_screenboard",
            "id": "rys-xwq-geh",
            "icon": None
        },
        {
            "popularity": 0,
            "is_shared": False,
            "author": {
                "handle": None,
                "name": None
            },
            "url": "/dash/host/3245468",
            "title": "agent-gui",
            "modified": None,
            "created": None,
            "is_favorite": False,
            "is_read_only": True,
            "type": "host_timeboard",
            "id": "3245468",
            "icon": None
        }
    ]
}

Ajouter des éléments à une liste de dashboards

Ajoutez des dashboards à une liste de dashboards existante.

Ce endpoint a été mis à jour afin de refléter les nouvelles modifications de l'API Dashboard. La documentation relative à l'ancien endpoint se trouve ici :

ARGUMENTS:

  • dashboards [obligatoire] : La liste des dashboards à ajouter à la liste. Les définitions de dashboard respectent le format suivant :

    • type [obligatoire] : Le type du dashboard. Le type doit être correspondre à l’une des valeurs suivantes :

      • "custom_timeboard"
      • "custom_screenboard"
      • "integration_screenboard"
      • "integration_timeboard"
      • "host_timeboard"
    • id [obligatoire] : L’ID du dashboard.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

POST /v2/dashboard/lists/manual/<LIST_ID>/dashboards

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

list_id = 4741
dashboards = [
    {
        'type': 'custom_screenboard',
        'id': 'rys-xwq-geh'
    },
    {
        'type': 'custom_timeboard',
        'id': 'qts-q2k-yq6'
    },
    {
        'type': 'integration_screenboard',
        'id': '87'
    },
    {
        'type': 'integration_timeboard',
        'id': '23'
    },
    {
        'type': 'host_timeboard',
        'id': '3245468'
    }
]

api.DashboardList.v2.add_items(list_id, dashboards=dashboards)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

list_id = 4741
dashboards = [
    {
        "type" => "custom_screenboard",
        "id" => "rys-xwq-geh"
    },
    {
        "type" => "custom_timeboard",
        "id" => "qts-q2k-yq6"
    },
    {
        "type" => "integration_screenboard",
        "id" => "87"
    },
    {
        "type" => "integration_timeboard",
        "id" => "23"
    },
    {
        "type" => "host_timeboard",
        "id" => "3245468"
    }
]

result = dog.v2.add_items_to_dashboard_list(list_id, dashboards)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

list_id=4741

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "dashboards": [
            {
                "type": "custom_screenboard",
                "id": "rys-xwq-geh"
            },
            {
                "type": "custom_timeboard",
                "id": "qts-q2k-yq6"
            },
            {
                "type": "integration_screenboard",
                "id": "87"
            },
            {
                "type": "integration_timeboard",
                "id": "23"
            },
            {
                "type": "host_timeboard",
                "id": "3245468"
            }
        ]
}' \
"https://api.datadoghq.com/api/v2/dashboard/lists/manual/${list_id}/dashboards"

EXAMPLE RESPONSE:

{
    'added_dashboards_to_list': [
        {
            'type': 'custom_screenboard',
            'id': 'rys-xwq-geh'
        },
        {
            'type': 'custom_timeboard',
            'id': 'qts-q2k-yq6'
        },
        {
            'type': 'integration_screenboard',
            'id': '87'
        },
        {
            'type': 'integration_timeboard',
            'id': '23'
        },
        {
            'type': 'host_timeboard',
            'id': '3245468'
        }
    ]
}
[
    "200",
    {
        "added_dashboards_to_list" => [
            {
                "type" => "custom_screenboard",
                "id" => "rys-xwq-geh"
            },
            {
                "type" => "custom_timeboard",
                "id" => "qts-q2k-yq6"
            },
            {
                "type" => "integration_screenboard",
                "id" => "87"
            },
            {
                "type" => "integration_timeboard",
                "id" => "23"
            },
            {
                "type" => "host_timeboard",
                "id" => "3245468"
            }
        ]
    }
]
{
    "added_dashboards_to_list": [
        {
            "type": "custom_screenboard",
            "id": "rys-xwq-geh"
        },
        {
            "type": "custom_timeboard",
            "id": "qts-q2k-yq6"
        },
        {
            "type": "integration_screenboard",
            "id": "87"
        },
        {
            "type": "integration_timeboard",
            "id": "23"
        },
        {
            "type": "host_timeboard",
            "id": "3245468"
        }
    ]
}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Update Items of a Dashboard List

Update dashboards of an existing dashboard list.

This endpoint has been updated to reflect the new Dashboard API changes. Documentation for old endpoint is available here:

ARGUMENTS:

  • dashboards [required]: The new list of dashboards for the dashboard list. Dashboard definitions follow this form:

    • type [required]: The type of the dashboard. The type must be one of:

      • "custom_timeboard"
      • "custom_screenboard"
      • "integration_screenboard"
      • "integration_timeboard"
      • "host_timeboard"
    • id [required]: The id of the dashboard.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

PUT /v2/dashboard/lists/manual/<LIST_ID>/dashboards

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

list_id = 4741
dashboards = [
    {
        'type': 'custom_screenboard',
        'id': 'rys-xwq-geh'
    },
    {
        'type': 'custom_timeboard',
        'id': 'qts-q2k-yq6'
    },
    {
        'type': 'integration_screenboard',
        'id': '87'
    },
    {
        'type': 'integration_timeboard',
        'id': '23'
    },
    {
        'type': 'host_timeboard',
        'id': '3245468'
    }
]

api.DashboardList.v2.update_items(list_id, dashboards=dashboards)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

list_id = 4741
dashboards = [
    {
        "type" => "custom_screenboard",
        "id" => "rys-xwq-geh"
    },
    {
        "type" => "custom_timeboard",
        "id" => "qts-q2k-yq6"
    },
    {
        "type" => "integration_screenboard",
        "id" => "87"
    },
    {
        "type" => "integration_timeboard",
        "id" => "23"
    },
    {
        "type" => "host_timeboard",
        "id" => "3245468"
    }
]

result = dog.v2.update_items_of_dashboard_list(list_id, dashboards)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

list_id=4741

curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "dashboards": [
            {
                "type": "custom_screenboard",
                "id": "rys-xwq-geh"
            },
            {
                "type": "custom_timeboard",
                "id": "qts-q2k-yq6"
            },
            {
                "type": "integration_screenboard",
                "id": "87"
            },
            {
                "type": "integration_timeboard",
                "id": "23"
            },
            {
                "type": "host_timeboard",
                "id": "3245468"
            }
        ]
}' \
"https://api.datadoghq.com/api/v2/dashboard/lists/manual/${list_id}/dashboards"

EXAMPLE RESPONSE:

{
    'dashboards': [
        {
            'type': 'custom_timeboard',
            'id': 'qts-q2k-yq6'
        },
        {
            'type': 'custom_screenboard',
            'id': 'rys-xwq-geh'
        },
        {
            'type': 'integration_timeboard',
            'id': '23'
        },
        {
            'type': 'integration_screenboard',
            'id': '87'
        },
        {
            'type': 'host_timeboard',
            'id': '3245468'
        }
    ]
}
[
    "200",
    {
        "dashboards" => [
            {
                "type" => "custom_timeboard",
                "id" => "qts-q2k-yq6"
            },
            {
                "type" => "custom_screenboard",
                "id" => "rys-xwq-geh"
            },
            {
                "type" => "integration_timeboard",
                "id" => "23"
            },
            {
                "type" => "integration_screenboard",
                "id" => "87"
            },
            {
                "type" => "host_timeboard",
                "id" => "3245468"
            }
        ]
    }
]
{
    "dashboards": [
        {
            "type": "custom_timeboard",
            "id": "qts-q2k-yq6"
        },
        {
            "type": "custom_screenboard",
            "id": "rys-xwq-geh"
        },
        {
            "type": "integration_timeboard",
            "id": "23"
        },
        {
            "type": "integration_screenboard",
            "id": "87"
        },
        {
            "type": "host_timeboard",
            "id": "3245468"
        }
    ]
}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Delete Items from a Dashboard List

Delete dashboards from an existing dashboard list.

This endpoint has been updated to reflect the new Dashboard API changes. Documentation for old endpoint is available here:

ARGUMENTS:

  • dashboards [required]: A list of dashboards to remove from the list. Dashboard definitions follow this form:

    • type [required]: The type of the dashboard. The type must be one of:

      • "custom_timeboard"
      • "custom_screenboard"
      • "integration_screenboard"
      • "integration_timeboard"
      • "host_timeboard"
    • id [required]: The id of the dashboard.

SIGNATURE :

DELETE /v2/dashboard/lists/manual/<ID_LISTE>/dashboards

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

list_id = 4741
dashboards = [
    {
        'type': 'custom_screenboard',
        'id': 'rys-xwq-geh'
    },
    {
        'type': 'custom_timeboard',
        'id': 'qts-q2k-yq6'
    },
    {
        'type': 'integration_screenboard',
        'id': '87'
    },
    {
        'type': 'integration_timeboard',
        'id': '23'
    },
    {
        'type': 'host_timeboard',
        'id': '3245468'
    }
]

api.DashboardList.v2.delete_items(list_id, dashboards=dashboards)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

list_id = 4741
dashboards = [
    {
        "type" => "custom_screenboard",
        "id" => "rys-xwq-geh"
    },
    {
        "type" => "custom_timeboard",
        "id" => "qts-q2k-yq6"
    },
    {
        "type" => "integration_screenboard",
        "id" => "87"
    },
    {
        "type" => "integration_timeboard",
        "id" => "23"
    },
    {
        "type" => "host_timeboard",
        "id" => "3245468"
    }
]

result = dog.v2.delete_items_from_dashboard_list(list_id, dashboards)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

list_id=4741

curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "dashboards": [
            {
                "type": "custom_screenboard",
                "id": "rys-xwq-geh"
            },
            {
                "type": "custom_timeboard",
                "id": "qts-q2k-yq6"
            },
            {
                "type": "integration_screenboard",
                "id": "87"
            },
            {
                "type": "integration_timeboard",
                "id": "23"
            },
            {
                "type": "host_timeboard",
                "id": "3245468"
            }
        ]
}' \
"https://api.datadoghq.com/api/v2/dashboard/lists/manual/${list_id}/dashboards"

EXEMPLE DE RÉPONSE :

{
    'deleted_dashboards_from_list': [
        {
            'type': 'custom_screenboard',
            'id': 'rys-xwq-geh'
        },
        {
            'type': 'custom_timeboard',
            'id': 'qts-q2k-yq6'
        },
        {
            'type': 'integration_screenboard',
            'id': '87'
        },
        {
            'type': 'integration_timeboard',
            'id': '23'
        },
        {
            'type': 'host_timeboard',
            'id': '3245468'
        }
    ]
}
[
    "200",
    {
        "deleted_dashboards_from_list" => [
            {
                "type" => "custom_screenboard",
                "id" => "rys-xwq-geh"
            },
            {
                "type" => "custom_timeboard",
                "id" => "qts-q2k-yq6"
            },
            {
                "type" => "integration_screenboard",
                "id" => "87"
            },
            {
                "type" => "integration_timeboard",
                "id" => "23"
            },
            {
                "type" => "host_timeboard",
                "id" => "3245468"
            }
        ]
    }
]
{
    "deleted_dashboards_from_list": [
        {
            "type": "custom_screenboard",
            "id": "rys-xwq-geh"
        },
        {
            "type": "custom_timeboard",
            "id": "qts-q2k-yq6"
        },
        {
            "type": "integration_screenboard",
            "id": "87"
        },
        {
            "type": "integration_timeboard",
            "id": "23"
        },
        {
            "type": "host_timeboard",
            "id": "3245468"
        }
    ]
}

Downtimes

Les downtimes vous permettent de mieux contrôler les notifications d’un monitor en excluant des sous-groupes des contextes de l’alerte. Les paramètres de downtime, qui peuvent être planifiés avec une heure de début et de fin, désactivent toutes les notifications liées à des tags Datadog.

Planifier le downtime d’un monitor

ARGUMENTS:

  • scope [obligatoire] : Le contexte auquel s’applique le downtime, p. ex. host:app2. Vous pouvez fournir plusieurs contextes sous la forme d’une liste séparée par des virgules, p. ex. env:dev,env:prod. Le downtime obtenu s’applique aux sources qui correspondent à TOUS les contextes fournis (à savoir, env:dev ET env:prod), et PAS seulement à certains d’entre eux.
  • monitor_tags [facultatif, défaut=no monitor tag filter] : La liste de tags de monitor séparés par des virgules. Il s’agit des tags directement appliqués aux monitors, et non des tags utilisés dans les requêtes de monitor (qui sont filtrés par le paramètre scope), auxquels le downtime s’applique. Le downtime obtenu s’applique aux monitors qui correspondent à TOUS les tags de monitor fournis (à savoir, service:postgres ET team:frontend) et PAS seulement à certains d’entre eux.
  • monitor_id [facultatif, défaut=None] : Un monitor unique auquel le downtime s’applique. S’il n’est pas fourni, le downtime s’applique à tous les monitors.
  • start [facultatif, défaut=None] : Timestamp POSIX utilisé pour démarrer le downtime. S’il n’est pas fourni, le downtime commence au moment de sa création.
  • end [facultatif, défaut=None] : Timestamp POSIX utilisé pour arrêter le downtime. S’il n’est pas fourni, le downtime continue indéfiniment (c’est-à-dire, jusqu’à ce que vous l’annuliez).
  • message [facultatif, défaut=None] : Un message à inclure avec les notifications pour ce downtime. Les notifications par e-mail peuvent être envoyées à des utilisateurs spécifiques en utilisant la même notation « @nomutilisateur » que les événements.
  • timezone [facultatif, défaut=UTC] : Le fuseau horaire du downtime.
  • recurrence [facultatif, défaut=None] : Un objet définissant la récurrence du downtime avec une variété de paramètres :
    • type : le type de récurrence. Valeurs autorisées : days, weeks, months, years.
    • period : fréquence de répétition d’un entier. Par exemple, pour répéter tous les 3 jours, sélectionnez le type days et la période 3.
    • week_days (facultatif) : la liste des jours de la semaine pour laquelle la répétition est activée. Valeurs autorisées : Mon, Tue, Wed, Thu, Fri, Sat or Sun. Seulement applicable lorsque la variable type a pour valeur weeks. La première lettre doit être en majuscule.
    • until_occurrences (facultatif) ; nombre de récurrences du downtime. until_occurences et until_date sont mutuellement exclusifs.
    • until_date (facultatif) : timestamp POSIX correspondant à la date à laquelle la récurrence doit se terminer. until_occurences etuntil_date sont mutuellement exclusifs.

SIGNATURE:

POST /v1/downtime

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Repeat for 3 hours (starting now) on every week day for 4 weeks.
start_ts = int(time.time())
end_ts = start_ts + (3 * 60 * 60)
end_reccurrence_ts = start_ts + (4 * 7 * 24 * 60 * 60)  # 4 weeks from now

recurrence = {
    'type': 'weeks',
    'period': 1,
    'week_days': ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
    'until_date': end_reccurrence_ts
}

# Schedule downtime
api.Downtime.create(
    scope='env:staging',
    start=start_ts,
    end=end_ts,
    recurrence=recurrence
)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Repeat for 3 hours(starting now) on every week day for 4 weeks.
start_ts = Time.now.to_i
end_ts = start_ts + (3 * 60 * 60)
end_reccurrence_ts = start_ts + (4 * 7 * 24 * 60 * 60)# 4 weeks from now

recurrence = {
    'type' => 'weeks',
    'period' => 1,
    'week_days' => ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
    'until_date' => end_reccurrence_ts
}

# Schedule downtime
dog.schedule_downtime('env:testing', :start => start_ts, :end => end_ts, :recurrence => recurrence)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

start=$(date +%s)
end=$(date -v+3H +%s)
end_recurrence=$(date -v+21d +%s)

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "scope": "env:prod",
      "start": '"${start}"',
      "end": '"${end}"',
      "recurrence": {
        "type": "weeks",
        "period": 1,
        "week_days": ["Mon", "Tue", "Wed", "Thu", "Fri"],
        "until_date": '"${end_recurrence}"'
      }
}' \
    "https://api.datadoghq.com/api/v1/downtime"

EXEMPLE DE RÉPONSE:


{
    'active': True,
    'canceled': None,
    'creator_id': 3658,
    'disabled': False,
    'end': 1445978817,
    'id': 169267576,
    'message': None,
    'monitor_id': None,
    'monitor_tags': ['*'],
    'parent_id': None,
    'recurrence': {
        'period': 1,
        'type': 'weeks',
        'until_date': 1448387217,
        'until_occurrences': None,
        'week_days': [
            'Mon',
            'Tue',
            'Wed',
            'Thu',
            'Fri'
        ]
    },
    'scope': ['env:staging'],
    'start': 1445968017,
    'updater_id': None
}
[
    "200", {
        "disabled" => false,
        "canceled" => nil,
        "active" => true,
        "message" => nil,
        "id" => 169267581,
        "end" => 1445978819,
        "parent_id" => nil,
        "monitor_id" => nil,
        "monitor_tags": ["*"],
        "recurrence" => {
            "until_date" => 1448387219,
            "until_occurrences" => nil,
            "week_days" => ["Mon", "Tue", "Wed", "Thu", "Fri"],
            "type" => "weeks",
            "period" => 1
        },
        "start" => 1445968019,
        "creator_id" => 3658,
        "scope" => ["env:testing"],
        "updater_id" => nil
    }
]
{
  "active": true,
  "canceled": null,
  "creator_id": 3658,
  "disabled": false,
  "end": 1445979093,
  "id": 169267786,
  "message": null,
  "monitor_id": null,
  "monitor_tags": ["*"],
  "parent_id": null,
  "recurrence": {
    "period": 1,
    "type": "weeks",
    "until_date": 1447786293,
    "until_occurrences": null,
    "week_days": [
      "Mon",
      "Tue",
      "Wed",
      "Thu",
      "Fri"
    ]
  },
  "scope": [
    "env:prod"
  ],
  "start": 1445968293,
  "updater_id": null
}

Mettre à jour le downtime d’un monitor

ARGUMENTS:

  • id [obligatoire] : L’ID entier du downtime à mettre à jour.
  • scope [obligatoire] : Le contexte auquel s’applique le downtime, p. ex. host:app2. Vous pouvez fournir plusieurs contextes sous la forme d’une liste séparée par des virgules, p. ex. env:dev,env:prod. Le downtime obtenu s’applique aux sources qui correspondent à TOUS les contextes fournis (à savoir, env:dev ET env:prod), et PAS seulement à certains d’entre eux.
  • monitor_tags [facultatif, défaut=no monitor tag filter] : La liste de tags de monitor séparés par des virgules. Il s’agit des tags directement appliqués aux monitors, et non des tags utilisés dans les requêtes de monitor (qui sont filtrés par le paramètre scope), auxquels le downtime s’applique. Le downtime obtenu s’applique aux monitors qui correspondent à TOUS les tags de monitor fournis (à savoir, service:postgres ET team:frontend) et PAS seulement à certains d’entre eux.
  • monitor_id [facultatif, défaut=None] : Un monitor unique auquel le downtime s’applique. S’il n’est pas fourni, le downtime s’applique à tous les monitors.
  • start [facultatif, défaut=original start] : Timestamp POSIX utilisé pour démarrer le downtime.
  • end [facultatif, défaut=original end] : Timestamp POSIX utilisé pour arrêter le downtime. S’il n’est pas fourni, le downtime continue indéfiniment (c’est-à-dire, jusqu’à ce que vous l’annuliez).
  • message [obligatoire, défaut=original message] : Un message à inclure avec les notifications pour ce downtime. Les notifications par e-mail peuvent être envoyées à des utilisateurs spécifiques en utilisant la même notation « @nomutilisateur » que les événements.
  • timezone [facultatif, défaut=original timezone ] : Le fuseau horaire du downtime.
  • recurrence [facultatif, défaut=original recurrence] : Un objet définissant la récurrence du downtime avec une variété de paramètres :
    • type : le type de récurrence. Valeurs autorisées : days, weeks, months, years.
    • period : fréquence de répétition d’un entier. Par exemple, pour répéter tous les 3 jours, sélectionnez le type days et la période 3.
    • week_days (facultatif) : la liste des jours de la semaine pour laquelle la répétition est activée. Valeurs autorisées : Mon, Tue, Wed, Thu, Fri, Sat or Sun. Seulement applicable lorsque la variable type a pour valeur weeks. La première lettre doit être en majuscule.
    • until_occurrences (facultatif) ; nombre de récurrences du downtime. until_occurences et until_date sont mutuellement exclusifs.
    • until_date (facultatif) : timestamp POSIX correspondant à la date à laquelle la récurrence doit se terminer. until_occurences etuntil_date sont mutuellement exclusifs.

SIGNATURE:

PUT /v1/downtime/<ID_DOWNTIME>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Get an existing downtime
stagingDowntimes = []
downtimes = api.Downtime.get_all()

for item in downtimes:
    if item['scope'] == ['env:staging']:
        stagingDowntimes.append(item)

# Update that downtime
api.Downtime.update(
    stagingDowntimes[0]['id'],
    scope='env:staging',
    end=int(time.time()) + 60000,
    message="Doing some testing on staging."
)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Update downtime
stagingDowntimes = []
downtimes = dog.get_all_downtimes()
downtimes[1].each do |item |
        print item['scope']
if item['scope'] == ['env:staging']
stagingDowntimes.push item
end

end

dog.update_downtime(stagingDowntimes[0]['id'], :scope => 'env:testing', :end => Time.now.to_i + 60000, :message => "Doing some testing on staging.")
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
downtime_id=4336

# Create a downtime to update
currenttime=$(date +%s)
downtime_id=$(curl -X POST \
    -H "Content-type: application/json" \
    -H "DD-API-KEY: ${api_key}" \
    -H "DD-APPLICATION-KEY: ${app_key}" \
    -d "{
      \"scope\": \"env:prod\",
      \"start\": \"${currenttime}\"
    }" \
    "https://api.datadoghq.com/api/v1/downtime}" | jq '.id')

curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "scope": "env:staging",
      "message": "Doing some testing on staging"
}' \
"https://api.datadoghq.com/api/v1/downtime/${downtime_id}"

EXEMPLE DE RÉPONSE:


{
    'active': True,
    'disabled': False,
    'end': 1420447087,
    'id': 2910,
    'message': 'Doing some testing on staging.',
    'monitor_tags': ['*'],
    'scope': ['env:staging'],
    'start': 1420387032
}
[
    "200", {
        "end" => 1418303372,
        "disabled" => false,
        "start" => 1418224729,
        "active" => true,
        "monitor_tags": ["*"],
        "scope" => ["env:testing"],
        "message" => "Doing some testing on staging.",
        "id" => 4336
    }
]
{
  "active": true,
  "disabled": false,
  "end": 1418303372,
  "id": 4336,
  "message": "Doing some testing on staging",
  "monitor_tags": ["*"],
  "scope": [
    "env:staging"
  ],
  "start": 1418224729
}

Annuler le downtime d’un monitor

ARGUMENTS:

  • id [obligatoire] : L’ID entier du downtime à annuler.

SIGNATURE:

DELETE /v1/downtime/<DOWNTIME_ID>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Cancel downtime
api.Downtime.delete(1654)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)


dog.cancel_downtime(1655)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
downtime_id=1656

# Create a downtime to delete
currenttime=$(date +%s)
downtime_id=$(curl -X POST \
    -H "Content-type: application/json" \
    -H "DD-API-KEY: ${api_key}" \
    -H "DD-APPLICATION-KEY: ${app_key}" \
    -d "{
      \"scope\": \"env:prod\",
      \"start\": \"${currenttime}\"
    }" \
    "https://api.datadoghq.com/api/v1/downtime" | jq '.id')

curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/downtime/${downtime_id}"

EXEMPLE DE RÉPONSE:

Cet endpoint ne renvoie aucun objet JSON pour les requêtes réussies.

Annuler les downtimes d’un monitor selon le contexte

ARGUMENTS
  • scope [obligatoire] :
    Annulez tous les downtimes en fonction d’un ou plusieurs contextes donnés, comme :

    • env:prod
    • role:db,role:db-slave

SIGNATURE:

POST /v1/downtime/cancel/by_scope

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example 
#!/bin/bash

api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"

curl -X POST \
-H "Content-type: application/json" \
-H "Accept: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d "{
      \"scope\": \"host:i-123\"
}" \
"https://api.datadoghq.com/api/v1/downtime/cancel/by_scope"

EXEMPLE DE RÉPONSE:

#
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
#
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example 
{
  "cancelled_ids":[123456789,123456790]
}

Récupérer le downtime d’un monitor

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/downtime/<ID_DOWNTIME>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Get a downtime
api.Downtime.get(2910)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

puts dog.get_downtime(<DOWNTIME_ID>)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

downtime_id=2473

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/downtime/${downtime_id}"

EXEMPLE DE RÉPONSE:

{'active': True,
 'disabled': False,
 'end': 1420447087,
 'id': 2910,
 'message': 'Doing some testing on staging.',
 'monitor_tags': ['*'],
 'scope': ['env:staging'],
 'start': 1420387032
 }
{
  "end" => 1412793983,
  "disabled" => true,
  "start" => 1412792983,
  "active" => false,
  "monitor_tags" => ["*"],
  "scope" => ["env:staging"],
  "id" => 1625
}
{
  "active": True,
  "disabled": False,
  "end": 1420447087,
  "id": 2910,
  "message": "Doing some testing on staging.",
  "monitor_tags": ["*"],
  "scope": ["env:staging"],
  "start": 1420387032
}

Récupérer tous les downtimes de monitor

ARGUMENTS:

  • current_only [facultatif, défaut=False] : Ne renvoie que les downtimes actifs au moment de l’envoi de la requête.

SIGNATURE:

GET /v1/downtime

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Get all downtimes
print api.Downtime.get_all()
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Get all downtimes
dog.get_all_downtimes()
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/downtime"

EXEMPLE DE RÉPONSE:



[
    {
        'active': False,
        'disabled': True,
        'end': 1412793983,
        'id': 1625,
        'monitor_tags': ['*'],
        'scope': ['env:staging'],
        'start': 1412792983
    },
    {
        'active': False,
        'disabled': True,
        'end': None,
        'id': 1626,
        'monitor_tags': ['*'],
        'scope': ['*'],
        'start': 1412792985
    }
]
[
    "200", [{
        "end" => 1412793983,
        "disabled" => true,
        "start" => 1412792983,
        "active" => false,
        "monitor_tags" => ["*"],
        "scope" => ["env:staging"],
        "id" => 1625
    }, {
        "end" => nil,
        "disabled" => true,
        "start" => 1412792985,
        "active" => false,
        "monitor_tags" => ["*"],
        "scope" => ["*"],
        "id" => 1626
    }]
]
[
  {
    "active": false,
    "disabled": true,
    "end": 1412793983,
    "id": 1625,
    "monitor_tags": ["*"],
    "scope": [
      "env:staging"
    ],
    "start": 1412792983
  },
  {
    "active": false,
    "disabled": true,
    "end": null,
    "id": 1626,
    "monitor_tags": ["*"],
    "scope": [
      "*"
    ],
    "start": 1412792985
  }
]

Graphiques intégrables

Interagissez avec les graphiques intégrables via l’API.

Récupérer tous les embeds

Récupère la liste des graphiques intégrables précédemment créés.

Renvoie une liste au format JSON contenant toutes les informations sur les embeds précédemment créés à partir de l’UI et de l’API. Chaque réponse de graphique JSON suit la mise en forme renvoyée par GET api/v1/graph/embed/.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/graph/embed

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

# Intialize request parameters including API/APP key
options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Call Embed API function
api.Embed.get_all()
require 'rubygems'
require 'dogapi'

# Initialize API Client
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Get all with API Call
dog.get_all_embeds()
api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/graph/embed"

EXEMPLE DE RÉPONSE:

{
    "embedded_graphs": [
        {
            "embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
            "template_variables": [],
            "html": '&lt;iframe src=&quot;https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&amp;height=300&amp;width=600&amp;legend=true&quot; width=&quot;600&quot; height=&quot;300&quot; frameBorder=&quot;0&quot;&gt;&lt;/iframe&gt;',
            "graph_title": "Embed created through API",
            "revoked": False,
            "dash_url": None,
            "shared_by": 3658,
            "dash_name": None
        }
    ]
}
{
    "embedded_graphs" => [{
        "embed_id" => "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
        "template_variables" => [],
        "html" => '&lt;iframe src=&quot;https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&amp;height=300&amp;width=600&amp;legend=true&quot; width=&quot;600&quot; height=&quot;300&quot; frameBorder=&quot;0&quot;&gt;&lt;/iframe&gt;',
        "graph_title" => "Embed created through API",
        "revoked" => false,
        "dash_url" => nil,
        "shared_by" => 3658,
        "dash_name" => nil
    }]
}
{ "embedded_graphs": [
    {
      "embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
      "template_variables": [],
      "html": "&lt;iframe src=\&quot;https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&amp;height=300&amp;width=600&amp;legend=true\&quot; width=\&quot;600\&quot; height=\&quot;300\&quot; frameBorder=\&quot;0\&quot;&gt;&lt;/iframe&gt;",
      "graph_title": "Embed created through API",
      "revoked": false,
      "dash_url": null,
      "shared_by": 3658,
      "dash_name": null
    }
  ]
}

Créer un embed

Crée un nouveau graphique intégrable.

Renvoie un JSON composé des mêmes éléments renvoyés par GET api/v1/graph/embed/. En cas d’échec, la valeur renvoyée correspond à un JSON contenant un message d’erreur {errors: [messages]}.

Remarque : si un embed existe déjà pour la même requête dans une organisation donnée, au lieu de créer un nouvel embed, l’embed le plus ancien est renvoyé.

Si vous souhaitez utiliser des template variables, consultez la section Graphiques intégrables avec des template variables.

ARGUMENTS:

  • graph_json [obligatoire] : La définition du graphique en JSON. Même format que celui disponible dans l’onglet JSON de l’éditeur de graphiques dans Datadog.
  • timeframe [facultatif, défaut=1_hour] : Le timegrame pour le graphique. Doit correspondre à l’une des valeurs suivantes :
    • 1_hour
    • 4_hours
    • 1_day
    • 2_days
    • 1_week
  • size [facultatif, défaut=medium] : La taille du graphique. Valeurs autorisées :
    • small
    • medium
    • large
    • xlarge
  • legend [facultatif, défaut=no] : Le flag déterminant si le graphique inclut ou non une légende. Valeurs autorisées : yes ou no.
  • title [facultatif, défaut=Embed created through API] : Détermine le titre du graphique. Doit inclure au moins 1 caractère.

SIGNATURE:

POST /v1/graph/embed

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import json

# Intialize request parameters including API/APP key
options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Create an embed graph definition as a dict and format as JSON
graph_json = {
    "requests": [{
        "q": "avg:system.load.1{*}"
    }],
    "viz": "timeseries",
    "events": []
}
graph_json = json.dumps(graph_json)

api.Embed.create(
    graph_json=graph_json,
    timeframe="1_hour",
    size="medium",
    legend="no"
)
require 'rubygems'
require 'dogapi'

# Initialize API Client
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Prepare parameters
graph_json = '{
"requests": [{
    "q": "avg:system.load.1{*}"
}],
"viz": "timeseries",
"events": []
}
'
timeframe = "1_hour"
size = "medium"
legend = "no"
title = "Embed created through API"

# Create parameter hash
description = {:timeframe => timeframe, :size => size, :legend => legend, :title => title
}

# Make API Call
status, result = dog.create_embed(graph_json, description)
api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"

curl -X POST \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d 'graph_json={"requests":[{"q":"avg:system.load.1{*}"}],"viz":"timeseries","events":[]}' \
-d "timeframe=1_hour" \
-d "size=medium" \
-d "legend=yes" \
"https://api.datadoghq.com/api/v1/graph/embed"

EXEMPLE DE RÉPONSE:

{
    "embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
    "template_variables": [],
    "html": '&lt;iframe src=&quot;https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&amp;height=300&amp;width=600&amp;legend=true&quot; width=&quot;600&quot; height=&quot;300&quot; frameBorder=&quot;0&quot;&gt;&lt;/iframe&gt;',
    "graph_title": "Embed created through API",
    "revoked": False,
    "dash_url": None,
    "shared_by": 3658,
    "dash_name": None
}
{
    "embed_id" => "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
    "template_variables" => [],
    "html" => '&lt;iframe src=&quot;https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&amp;height=300&amp;width=600&amp;legend=true&quot; width=&quot;600&quot; height=&quot;300&quot; frameBorder=&quot;0&quot;&gt;&lt;/iframe&gt;',
    "graph_title" => "Embed created through API",
    "revoked" => false,
    "dash_url" => nil,
    "shared_by" => 3658,
    "dash_name" => nil
}
{
  "embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
  "template_variables": [],
  "html": "&lt;iframe src=\&quot;https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&amp;height=300&amp;width=600&amp;legend=true\&quot; width=\&quot;600\&quot; height=\&quot;300\&quot; frameBorder=\&quot;0\&quot;&gt;&lt;/iframe&gt;",
  "graph_title": "Embed created through API",
  "revoked": false,
  "dash_url": null,
  "shared_by": 3658,
  "dash_name": null
}

Récupérer un embed spécifique

Récupérez le fragment HTML d’un embed généré précédemment avec embed_id.

Renvoie un objet JSON avec 8 éléments :

  • embed_id : jeton de l’embed.
  • graph_title : titre du graphique.
  • dash_name : nom du dashboard sur lequel le graphique est affiché (null si aucun).
  • dash_url : URL du dashboard sur lequel le graphique est affiché (null si aucun).
  • shared_by : ID de l’utilisateur qui a partagé l’embed.
  • html : fragment HTML pour l’embed (iframe).
  • revoked : flag booléen indiquant si l’embed est révoqué ou non.

En cas d’échec, la valeur renvoyée correspond à un JSON contenant un message d’erreur {errors: [messages]}.

ARGUMENTS
  • size [facultatif, défaut=medium] : La taille du graphique. Valeurs autorisées :
    • small
    • medium
    • large
    • xlarge
  • legend [facultatif, défaut=no] : Le flag déterminant si le graphique inclut ou non une légende. Valeurs autorisées : yes ou no.
  • template_variables [facultatif, default=None] : Remplacez les template variables dans les requêtes par form $var. Pour remplacer $var par val, utilisez var=val comme paramètre pour chaque template variable que vous souhaitez remplacer. Si des template variables n’ont pas de valeur dans l’URL source de l’iframe, (*) est alors utilisé comme valeur.

SIGNATURE:

GET /v1/graph/embed/<ID_EMBED>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

# Intialize request parameters including API/APP key
options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Set Embed ID (token)
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

# Call Embed API function
api.Embed.get(embed_id, legend="no", size="medium", timeframe="1_hour")
require 'rubygems'
require 'dogapi'

# Initialize API Client
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Initialize Embed Token / ID
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

# Get embed with API Call
dog.enable_embed(embed_id)
api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"

embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/graph/embed/${embed_id}"

EXEMPLE DE RÉPONSE:

{
    "embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
    "template_variables": [],
    "html": '&lt;iframe src=&quot;https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&amp;height=300&amp;width=600&amp;legend=true&quot; width=&quot;600&quot; height=&quot;300&quot; frameBorder=&quot;0&quot;&gt;&lt;/iframe&gt;',
    "graph_title": "Embed created through API",
    "revoked": False,
    "dash_url": None,
    "shared_by": 3658,
    "dash_name": None
}
{
    "embed_id" => "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
    "template_variables" => [],
    "html" => '&lt;iframe src=&quot;https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&amp;height=300&amp;width=600&amp;legend=true&quot; width=&quot;600&quot; height=&quot;300&quot; frameBorder=&quot;0&quot;&gt;&lt;/iframe&gt;',
    "graph_title" => "Embed created through API",
    "revoked" => false,
    "dash_url" => nil,
    "shared_by" => 3658,
    "dash_name" => nil
}
{
  "embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
  "template_variables": [],
  "html": "&lt;iframe src=\&quot;https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&amp;height=300&amp;width=600&amp;legend=true\&quot; width=\&quot;600\&quot; height=\&quot;300\&quot; frameBorder=\&quot;0\&quot;&gt;&lt;/iframe&gt;",
  "graph_title": "Embed created through API",
  "revoked": false,
  "dash_url": null,
  "shared_by": 3658,
  "dash_name": null
}

Activer un embed

Active un embed spécifié.

Renvoie un JSON contenant le message de réussite {success: [message]}. En cas d’échec, la valeur renvoyée correspond à un JSON contenant un message d’erreur {errors: [messages]}.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/graph/embed/<ID_EMBED>/enable

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

# Intialize request parameters including API/APP key
options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Set Embed ID (token)
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

# Call Embed API function
api.Embed.enable(embed_id)
require 'rubygems'
require 'dogapi'

# Initialize API Client
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Initialize Embed Token / ID
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

# Enable with API Call
dog.enable_embed(embed_id)
api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"
embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/graph/embed/${embed_id}/enable"

EXEMPLE DE RÉPONSE:

{
    "success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully enabled."
}
{
    "success" => "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully enabled."
}
{
  "success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully enabled."
}

Révoquer un embed

Révoque un embed spécifié.

Renvoie un JSON contenant le message de réussite {success: [message]}. En cas d’échec, la valeur renvoyée correspond à un JSON contenant un message d’erreur {errors: [messages]}.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/graph/embed/<EMBED_ID>/revoke

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

# Intialize request parameters including API/APP key
options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Set Embed ID (token)
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

# Call Embed API function
api.Embed.revoke(embed_id)
require 'rubygems'
require 'dogapi'

# Initialize API Client
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Initialize Embed Token / ID
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

# Revoke with API Call
dog.revoke_embed(embed_id)
api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"

embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/graph/embed/${embed_id}/revoke"

EXEMPLE DE RÉPONSE :

{
    "success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully revoked."
}
{
    "success" => "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully revoked."
}
{
  "success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully revoked."
}

Événements

Le service d’événements vous permet de programmer l’envoi d’événements dans le flux d’événements et d’extraire des événements du flux d’événements.

Les événements ne peuvent pas dépasser 4 000 caractères. Si un événement est envoyé avec un message contenant plus de 4 000 caractères, seuls les 4000 premiers caractères seront affichés.

Envoyer un événement

Cet endpoint vous permet d’envoyer des événements dans le flux. Taguez-les, définissez leur priorité et regroupez-les avec d’autres événements.

ARGUMENTS:

  • title [obligatoire] : Le titre de l’événement. Limité à 100 caractères. Utilisez msg_title avec la bibliothèque Datadog Ruby.
  • text [obligatoire] : Le corps de l’événement. Limité à 4 000 caractères. Le texte prend en charge le Markdown. Utilisez msg_text avec la bibliothèque Datadog Ruby.
  • date_happened [facultatif, défaut=now] : Le timestamp POSIX de l’événement. Doit être envoyé sous la forme d’un entier (sans guillemets). Limité aux événements de moins d’un an et 24 jours (389 jours).
  • priority [facultatif, défaut=normal] : La priorité de l’événement : normal ou low.
  • host [facultatif, défaut=None] : Hostname à associer à l’événement. Tous les tags associés au host sont également appliqués à cet événement.
  • tags [facultatif, défaut=None] : La liste des tags à appliquer à l’événement.
  • alert_type [facultatif, défaut=info] : S’il s’agit d’un événement d’alerte, définissez son type parmi les valeurs suivantes : error, warning, info ou success.
  • aggregation_key [facultatif, défaut=None] : Chaîne arbitraire à utiliser pour l’agrégation. Limitée à 100 caractères. Si vous spécifiez une clé, tous les événements utilisant cette clé sont regroupés dans le flux d’événements.
  • source_type_name [facultatif, défaut=None] : Le type d’événement envoyé. Valeurs autorisées : nagios, hudson, jenkins, my_apps, chef, puppet, git, bitbucket, etc. Liste complète des valeurs d’attributs source
  • related_event_id [facultatif, défaut=None] : ID de l’événement parent. Doit être envoyé sous la forme d’un entier (c’est-à-dire sans apostrophes).
  • device_name [facultatif, défaut=None] : La liste des noms d’appareils avec lesquels publier l’événement.

SIGNATURE:

POST /v1/events

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

title = "Something big happened!"
text = 'And let me tell you all about it here!'
tags = ['version:1', 'application:web']

api.Event.create(title=title, text=text, tags=tags)

# If you are programmatically adding a comment to this new event
# you might want to insert a pause of .5 - 1 second to allow the
# event to be available.
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# submitting events doesn 't require an application_key, 
# so we don't bother setting it
dog = Dogapi::Client.new(api_key)

dog.emit_event(Dogapi::Event.new('msg_text', :msg_title => 'Title'))

# If you are programmatically adding a comment to this new event
# you might want to insert a pause of.5 - 1 second to allow the
# event to be available.


curl  -X POST -H "Content-type: application/json" \
-d '{
      "title": "Did you hear the news today?",
      "text": "Oh boy!",
      "priority": "normal",
      "tags": ["environment:test"],
      "alert_type": "info"
}' \
"https://api.datadoghq.com/api/v1/events?api_key=<YOUR_API_KEY>"

EXEMPLE DE RÉPONSE:

{
    'event':
    {
        'date_happened': 1419436860,
        'handle': None,
        'id': 2603387619536318140,
        'priority': 'normal',
        'related_event_id': None,
        'tags': ['version:1', 'application:web'],
        'text': 'And let me tell you all about it here!',
        'title': 'Something big happened!',
        'url': 'https://app.datadoghq.com/event/jump_to?event_id=2603387619536318140'
    },
    'status': 'ok'
}
[
    "202", {
        "status" => "ok",
        "event" => {
            "priority" => "normal",
            "date_happened" => 1346452418,
            "title" => "Title",
            "url" =>
            "https://app.datadoghq.com/event/jump_to?event_id=1378911893708573827",
            "text" => "msg_text",
            "tags" => [],
            "related_event_id" => nil,
            "id" => 1378911893708573827
        }
    }
]
{
  "event": {
    "date_happened": 1346449298,
    "handle": null,
    "id": 1378859526682864843,
    "priority": "normal",
    "related_event_id": null,
    "tags": [
      "environment:test"
    ],
    "text": null,
    "title": "Did you hear the news today?",
    "url": "https://app.datadoghq.com/event/jump_to?event_id=1378859526682864843"
  },
  "status": "ok"
}

Récupérer un événement

Cet endpoint vous permet d’interroger un événement pour obtenir des informations à son sujet. Remarque : si l’événement que vous interrogez comprend de la mise en forme Markdown, les caractères « % », « \ » ou encore « n » peuvent s’afficher dans votre sortie.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/events/<ID_ÉVÉNEMENT>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

api.Event.get(2603387619536318140)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

event_id = '1375909614428331251'
dog.get_event(event_id)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
event_id=1377281704830403917

# Create an event to get
event_id=$(curl  -X POST -H "Content-type: application/json" -d "{\"title\": \"Did you hear the news today?\"}" "https://api.datadoghq.com/api/v1/events?api_key=<YOUR_API_KEY>" | jq -r '.event.url|ltrimstr("https://app.datadoghq.com/event/event?id=")')
sleep 5

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/events/${event_id}"

EXEMPLE DE RÉPONSE:


{
    'event': {
        'alert_type': 'info',
        'date_happened': 1419436860,
        'device_name': None,
        'host': None,
        'id': 2603387619536318140,
        'payload': '{}',
        'priority': 'normal',
        'resource': '/api/v1/events/2603387619536318140',
        'tags': ['application:web', 'version:1'],
        'text': 'And let me tell you all about it here!',
        'title': 'Something big happened!',
        'url': '/event/jump_to?event_id=2603387619536318140'
    }
}
[
    "200", {
        "event" => {
            "date_happened" => 1346273469,
            "alert_type" => "info",
            "resource" => "/api/v1/events/1375909614428331251",
            "title" => "Something big happened!",
            "url" => "/event/jump_to?event_id=1375909614428331251",
            "text" => "And let me tell you all about it here!",
            "tags" => ["application:web", "version:1"],
            "id" => 1375909614428331251,
            "priority" => "normal",
            "host" => nil,
            "device_name" => nil,
            "payload" => "{}"
        }
    }
]
{
  "event": {
    "alert_type": "info",
    "date_happened": 1346355252,
    "device_name": null,
    "host": null,
    "id": 1377281704830403917,
    "payload": "{}",
    "priority": "normal",
    "resource": "/api/v1/events/1377281704830403917",
    "tags": [
      "environment:test"
    ],
    "text": "Oh boy!",
    "title": "Did you hear the news today?",
    "url": "/event/jump_to?event_id=1377281704830403917"
  }
}

Interroger le flux d’événements

Le flux d’événements peut être interrogé et filtré par période, priorité, sources et tags. Remarque : si l’événement que vous interrogez comprend de la mise en forme Markdown, les caractères « % », « \ » ou encore « n » peuvent s’afficher dans votre sortie.

ARGUMENTS:

  • start [obligatoire] : Timestamp POSIX.
  • end [obligatoire] : Timestamp POSIX.
  • priority [facultatif, défaut=None] : Priorité de vos événements : normal ou low.
  • sources [facultatif, défaut=None] : Une chaîne de sources séparées par des virgules.
  • tags [facultatif, défaut=None] : Une chaîne de tags séparés par des virgules. Pour utiliser un filtre de tags négatif, ajoutez le préfixe - à votre tag. Consultez la documentation relative au flux d’événements pour en savoir plus.
  • unaggregated [facultatif, défaut=false] : Définissez ce paramètre sur true pour renvoyer tous les événements compris dans l’intervalle [start,end] indiqué. Si un événement est agrégé à un événement parent avec un timestamp en dehors de cet intervalle, il ne sera pas compris dans la sortie.

SIGNATURE:

GET /v1/events

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

end_time = time.time()
start_time = end_time - 100

api.Event.query(
    start=start_time,
    end=end_time,
    priority="normal",
    tags=["-env:dev,application:web"],
    unaggregated=True
)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

end_time = Time.now.to_i
start_time = end_time - 100

dog.stream(start_time, end_time, :priority => "normal", :tags => ["-env:dev,application:web"], :unaggregated => true)
# Note: this endpoint only accepts form-encoded requests.
currenttime=$(date +%s)
currenttime2=$(date --date='1 day ago' +%s)

curl -X GET \
    -H "Content-type: application/json" \
    -H "DD-API-KEY: $api_key" \
    -H "DD-APPLICATION-KEY: $app_key" \
    "https://api.datadoghq.com/api/v1/events?&start=${currenttime2}&end=${currenttime}&tags=check_type:api&sources=alert&unaggregated=true"

EXEMPLE DE RÉPONSE:

{
    'events': [
        {
            'alert_type': 'info',
            'comments': [],
            'date_happened': 1346273496,
            'device_name': null,
            'host': null,
            'id': 1375910067732769979,
            'is_aggregate': false,
            'priority': 'normal',
            'resource': '/api/v1/events/1375910067732769979',
            'source': 'My Apps',
            'tags': [
                'application:web',
                'version:1'
            ],
            'text': 'And let me tell you all about it here!',
            'title': 'Something big happened!',
            'url': '/event/jump_to?event_id=1375910067732769979'
        },
        {
            'alert_type': 'info',
            'comments': [],
            'date_happened': 1346273469,
            'device_name': null,
            'host': null,
            'id': 1375909614428331251,
            'is_aggregate': false,
            'priority': 'normal',
            'resource': '/api/v1/events/1375909614428331251',
            'source': 'My Apps',
            'tags': [
                'application:web',
                'version:1'
            ],
            'text': 'And let me tell you all about it here!',
            'title': 'Something big happened!',
            'url': '/event/jump_to?event_id=1375909614428331251'
        }
    ]
}
["200", {
    "events" => [{
        "events" => [{
            "alert_type" => "info",
            "comments" => [],
            "date_happened" => 1346273496,
            "device_name" => null,
            "host" => null,
            "id" => 1375910067732769979,
            "is_aggregate" => false,
            "priority" => "normal",
            "resource" => "/api/v1/events/1375910067732769979",
            "source" => "My Apps",
            "tags" => [
                "application:web",
                "version:1"
            ],
            "text" => "And let me tell you all about it here!",
            "title" => "Something big happened!",
            "url" => "/event/jump_to?event_id=1375910067732769979"
        }, {
            "alert_type" => "info",
            "comments" => [],
            "date_happened" => 1346273469,
            "device_name" => null,
            "host" => null,
            "id" => 1375909614428331251,
            "is_aggregate" => false,
            "priority" => "normal",
            "resource" => "/api/v1/events/1375909614428331251",
            "source" => "My Apps",
            "tags" => [
                "application:web",
                "version:1"
            ],
            "text" => "And let me tell you all about it here!",
            "title" => "Something big happened!",
            "url" => "/event/jump_to?event_id=1375909614428331251"
        }]
    }]
}]
{
  "events": [
    {
      "alert_type": "info",
      "comments": [],
      "date_happened": 1346273496,
      "device_name": null,
      "host": null,
      "id": 1375910067732769979,
      "is_aggregate": false,
      "priority": "normal",
      "resource": "/api/v1/events/1375910067732769979",
      "source": "My Apps",
      "tags": [
        "application:web",
        "version:1"
      ],
      "text": "And let me tell you all about it here!",
      "title": "Something big happened!",
      "url": "/event/jump_to?event_id=1375910067732769979"
    },
    {
      "alert_type": "info",
      "comments": [],
      "date_happened": 1346273469,
      "device_name": null,
      "host": null,
      "id": 1375909614428331251,
      "is_aggregate": false,
      "priority": "normal",
      "resource": "/api/v1/events/1375909614428331251",
      "source": "My Apps",
      "tags": [
        "application:web",
        "version:1"
      ],
      "text": "And let me tell you all about it here!",
      "title": "Something big happened!",
      "url": "/event/jump_to?event_id=1375909614428331251"
    }
  ]
}

Graphiques

Prenez des snapshots de graphiques à l’aide de l’API.

Snapshot de graphique

Remarque : lorsqu’un snapshot est créé, vous devez attendre un certain temps avant de pouvoir y accéder.

ARGUMENTS:

  • metric_query [obligatoire] : la requête de la métrique.
  • start [obligatoire] : le timestamp POSIX de début de la requête.
  • end [obligatoire] : le timestamp POSIX de fin de la requête.
  • event_query [facultatif, défaut=None] : une requête qui ajoute des lignes d’événements au graphique.
  • graph_def [facultatif, défaut=None] : un document JSON définissant le graphique. graph_def peut être utilisé à la place de metric_query. Le document JSON utilise la grammaire définie ici et doit être formaté sur une seule ligne. L’encodage URL convertit ensuite le contenu du document de façon à pouvoir le transmettre en ligne.
  • title [facultatif, défaut=None] : le titre du graphique. Si aucun titre n’est spécifié, le graphique n’a pas de titre.

SIGNATURE:

GET /v1/graph/snapshot

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Take a graph snapshot
end = int(time.time())
start = end - (60 * 60)
api.Graph.create(
    graph_def='{\
    "viz": "timeseries", \
    "requests": [ \
      {"q": "avg:system.load.1{*}", "conditional_formats": [], "type": "line"},\
      {"q": "avg:system.load.5{*}", "type": "line"}, \
      {"q": "avg:system.load.15{*}", "type": "line"}\
      ], \
    "events": [\
      {"q": "hosts:* ", "tags_execution": "and"}\
      ]}',
    start=start,
    end=end
)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

end_ts = Time.now().to_i
start_ts = end_ts - (60 * 60)
dog.graph_snapshot("system.load.1{*}", start_ts, end_ts)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

end_date=$(date +%s)
start_date=$(($end_date - 86400))

curl -X GET \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/graph/snapshot?metric_query=system.load.1\{*\}&start=${start_date}&end=${end_date}"

EXEMPLE DE RÉPONSE:

{
    'graph_def': {"viz": "timeseries", "requests": [{"q": "avg:system.load.1{*}", "conditional_formats": [], "type": "line"}, {"q": "avg:system.load.5{*}", "type": "line"}, {"q": "avg:system.load.15{*}", "type": "line"}], "events": [{"q": "hosts:* ", "tags_execution": "and"}]}',
    'metric_query': 'system.load.1{*}',
    'snapshot_url': 'https://s3.amazonaws.com/dd-snapshots-prod/org_1499/2013-07-19/2459d291fc021c84f66aac3a87251b6c92b589da.png'
}
["200", {
    "metric_query" => "system.load.1{*}",
    "snapshot_url" =>
    "https://s3.amazonaws.com/dd-snapshots-prod/org_1499/2013-07-19/7f6dd29198ce0872a6fdfab33f534ef8d64a23ea.png"
}]
{
  "metric_query": "system.load.1{*}",
  "snapshot_url": "https://s3.amazonaws.com/dd-snapshots-prod/org_1499/2013-07-19/53fd79f024e7796f4ca399f1d90adf3cf95a9bb8.png"
}

Hosts

Rechercher des hosts

Cet endpoint permet de rechercher les hosts selon leur nom, alias ou tag. Les hosts actifs au cours des trois dernières heures sont inclus. Les résultats sont paginés avec un maximum de 100 résultats par recherche.

ARGUMENTS:

  • filter [facultatif, défaut=None] : chaîne de requête pour filtrer les résultats de la recherche.
  • sort_field [facultatif, défaut=cpu] : trie les hosts selon un champ donné. Valeurs autorisées : status, apps, cpu, iowait ou load.
  • sort_dir [facultatif, défaut=desc] : l’ordre de tri. Valeurs autorisées : asc ou desc.
  • start [facultatif, défaut=0] : résultat des hosts à partir desquels commencer la recherche.
  • count [facultatif, défaut=100] : nombre de hosts à renvoyer, max. 100.
  • from [facultatif, défaut=now - 2 hours] : le nombre de secondes depuis l’epoch UNIX à partir duquel la recherche de hosts doit être effectuée.

SIGNATURE:

GET /v1/hosts

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

api.Hosts.search()
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.search_hosts()
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/hosts"

EXEMPLE DE RÉPONSE:

{
  'total_returned': 1,
  'host_list': [
    {
      'name': 'i-deadbeef',
      'up': True,
      'is_muted': False,
      "last_reported_time": 1560000000,
      'apps': [
        'agent'
      ],
      'tags_by_source': {
        'Datadog': [
          'host:i-deadbeef'
        ],
        'Amazon Web Services': [
          'account:staging'
        ]
      },
      'aws_name': 'mycoolhost-1',
      'metrics': {
        'load': 0.5,
        'iowait': 3.2,
        'cpu': 99.0
      },
      'sources': [
        'aws',
        'agent'
      ],
      'meta': {
        'nixV': [
          'Ubuntu',
          '14.04',
          'trusty'
        ]
      },
      'host_name': 'i-deadbeef',
      'id': 123456,
      'aliases': [
        'mycoolhost-1'
      ]
    }
  ],
  'total_matching': 1
}
["200", {
  "total_returned": 1,
  "host_list": [
    {
      "name": "i-deadbeef",
      "up": true,
      "is_muted": false,
      "last_reported_time": 1560000000,
      "apps": [
        "agent"
      ],
      "tags_by_source": {
        "Datadog": [
          "host:i-deadbeef"
        ],
        "Amazon Web Services": [
          "account:staging"
        ]
      },
      "aws_name": "mycoolhost-1",
      "metrics": {
        "load": 0.5,
        "iowait": 3.2,
        "cpu": 99.0
      },
      "sources": [
        "aws",
        "agent"
      ],
      "meta": {
        "nixV": [
          "Ubuntu",
          "14.04",
          "trusty"
        ]
      },
      "host_name": "i-deadbeef",
      "id": 123456,
      "aliases": [
        "mycoolhost-1"
      ]
    }
  ],
  "total_matching": 1
}]
{
  "total_returned": 1,
  "host_list": [
    {
      "name": "i-deadbeef",
      "up": true,
      'is_muted': true,
      'mute_timeout': 1560010000,
      "last_reported_time": 1560000000,
      "apps": [
        "agent"
      ],
      "tags_by_source": {
        "Datadog": [
          "host:i-deadbeef"
        ],
        "Amazon Web Services": [
          "account:staging"
        ]
      },
      "aws_name": "mycoolhost-1",
      "metrics": {
        "load": 0.5,
        "iowait": 3.2,
        "cpu": 99.0
      },
      "sources": [
        "aws",
        "agent"
      ],
      "meta": {
        "nixV": [
          "Ubuntu",
          "14.04",
          "trusty"
        ]
      },
      "host_name": "i-deadbeef",
      "id": 123456,
      "aliases": [
        "mycoolhost-1"
      ]
    }
  ],
  "total_matching": 1
}

Nombre de hosts

Cet endpoint renvoie le nombre total de hosts actifs et disponibles dans votre compte Datadog. Un host est considéré comme actif lorsqu’il a transmis des données au cours de la dernière heure et disponible lorsque sa dernière transmission de données a été effectuée au cours des deux dernières heures.

ARGUMENTS:

  • from [facultatif, défaut=now - 2 hours] : Le nombre de secondes depuis l’epoch UNIX à partir duquel vous souhaitez obtenir le nombre total de hots actifs et disponibles.

SIGNATURE:

GET /v1/hosts/totals

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

api.Hosts.totals()
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.host_totals()
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/hosts/totals"

EXEMPLE DE RÉPONSE:

{'total_up':1750,'total_active':1759}
["200", {"total_up":1750,"total_active":1759}]
{"total_up":1750,"total_active":1759}

Désactiver un host

ARGUMENTS:

  • end [facultatif, défaut=None] : timestamp POSIX du moment où le host est réactivé. S’il est omis, le host reste désactivé jusqu’à ce qu’il soit explicitement réactivité.
  • message [facultatif, défaut=None] : message à associer à la désactivation de ce host.
  • override [facultatif, défaut=False] : si la valeur est true et le host est déjà désactivé, remplace les paramètres de désactivation du host existants.

SIGNATURE:

POST /v1/host/<HOSTNAME>/mute

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Find a host to mute
hosts = api.Hosts.search(q='hosts:')
# Mute a host
api.Host.mute(hosts['results']['hosts'][0])
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

hostname = "test.host"
message = "Muting this host for a test."
end_ts = Time.now.to_i + 60 * 60
dog.mute_host(hostname, :message => message, :end => end_ts)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "message": "Muting this host for a test!"
}' \
"https://api.datadoghq.com/api/v1/host/test.host/mute"

EXEMPLE DE RÉPONSE:


{
    'action': 'Muted',
    'hostname': 'test.host'
}
["200", {
	"action"=>"Muted", 
	"message"=>"Muting this host for a test.", 
	"hostname"=>"test.host", 
	"end"=>1433345249
}]
{
  "action": "Muted",
  "hostname": "test.host",
  "message": "Muting this host for a test!"
}

Réactiver un host

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

POST /v1/host/<HOSTNAME>/unmute

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Find a host to unmute
hosts = api.Hosts.search(q='hosts:')

# Unmute host
api.Host.unmute(hosts['results']['hosts'][0])
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

hostname = "test.host"
dog.unmute_host(hostname)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST \
-H "Content-type: application/json"
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/host/test.host/unmute"

EXEMPLE DE RÉPONSE:

{
    'action': 'Unmuted',
    'hostname': 'test.host'
}
["200", {
    "action" => "Unmuted",
    "hostname" => "test.host"
}]
{
  "action": "Unmuted",
  "hostname": "test.host"
}

Intégration AWS

Les endpoints AWS ne sont pas pris en charge dans les bibliothèques client de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Configurez votre intégration Datadog/AWS directement avec l’API Datadog.
Pour en savoir plus, consultez la page sur l’intégration AWS.

Énumérer toutes les intégrations AWS

Énumérer toutes les intégrations Datadog/AWS disponibles au sein de votre organisation Datadog.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/aws

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.get_integration('aws')
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

# List AWS Accounts (role-based only) in Datadog
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/aws"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{
  "accounts" => [{
    "errors" => [],
    "account_id" => "<AWS_ACCOUNT_ID>",
    "host_tags" => ["<KEY>:<VALUE>"],
    "account_specific_namespace_rules" => {},
    "role_name" => "DatadogAWSIntegrationRole",
    "filter_tags" => ["<KEY>:<VALUE>"]
  }]
}
{"accounts":
    [{
        "account_id": '112233445566',
        "role_name": "SomeDatadogRole",
        "filter_tags": ["filter123"],
        "host_tags": ["account":"demo"],
        "account_specific_namespace_rules": {"opsworks":false}
    }]
}

Créer une intégration AWS

Créer une intégration Datadog/Amazon Web Services.

Remarque : la méthode POST permet de mettre à jour la configuration de votre intégration en ajoutant votre nouvelle configuration à celle déjà existante dans votre organisation Datadog.

ARGUMENTS:

Le tableau de tags EC2 (sous la forme key:value) définit un filtre, qui est utilisé par Datadog lors de la collecte des métriques de EC2. Les wildcards, tels que ? (pour un seul caractère) et * (pour plusieurs caractères), peuvent également être utilisés. Seuls les hosts qui correspondent à l’un des tags définis sont importés dans Datadog. Les autres hosts sont ignorés. Ajoutez ! devant un tag pour exclure le host correspondant à ce tag. Exemple ; env:production,instance-type:c1.*,!region:us-east-1. Lisez la documentation relative aux tags AWS pour en savoir plus sur l’ajout de tags EC2.

  • host_tags [facultatif, défaut=None] :

    Tableau de tags (sous la forme key:value) à ajouter à tous les hosts et toutes les métriques transmettant des données via cette intégration.

  • account_specific_namespace_rules [facultatif, défaut=None] :

Un objet (sous la forme {"namespace1":true/false, "namespace2":true/false}) qui permet d’activer ou de désactiver la collecte de métriques de certains espaces de nommage AWS, uniquement pour ce compte AWS. La liste des espaces de nommage est disponible dans l’endpoint /v1/integration/aws/available_namespace_rules.

SIGNATURE:

POST /v1/integration/aws

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

config = {
  "account_id": "<AWS_ACCOUNT_ID>",
  "filter_tags": ["<KEY>:<VALUE>"],
  "host_tags": ["<KEY>:<VALUE>"],
  "role_name": "DatadogAWSIntegrationRole",
  "account_specific_namespace_rules": {"auto_scaling": false, "opsworks": false}
}

dog.create_integration('aws',config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

# Create an AWS Account in Datadog
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "account_id": "<AWS_ACCOUNT_ID>",
        "filter_tags": ["<KEY>:<VALUE>"],
        "host_tags": ["<KEY>:<VALUE>"],
        "role_name": "DatadogAWSIntegrationRole",
        "account_specific_namespace_rules": {
        	"auto_scaling": false,
        	"opsworks": false
        }
    }'\
"https://api.datadoghq.com/api/v1/integration/aws"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{
    "external_id"=> "12345678910111213"
}
{
    "external_id": "12345678910111213"
}

Mettre à jour une intégration AWS

Mettre à jour une intégration Datadog/Amazon Web Services.

Remarque : la méthode PUT permet de mettre à jour la configuration de votre intégration en remplaçant votre configuration actuelle par une nouvelle, envoyée à votre organisation Datadog.

ARGUMENTS:

Le tableau de tags EC2 (sous la forme key:value) définit un filtre, qui est utilisé par Datadog lors de la collecte des métriques de EC2. Les wildcards, tels que ? (pour un seul caractère) et * (pour plusieurs caractères), peuvent également être utilisés. Seuls les hosts qui correspondent à l’un des tags définis sont importés dans Datadog. Les autres hosts sont ignorés. Ajoutez ! devant un tag pour exclure le host correspondant à ce tag. Exemple ; env:production,instance-type:c1.*,!region:us-east-1. Lisez la documentation relative aux tags AWS pour en savoir plus sur l’ajout de tags EC2.

  • host_tags [facultatif, défaut=None] :

    Tableau de tags (sous la forme key:value) à ajouter à tous les hosts et toutes les métriques transmettant des données via cette intégration.

  • account_specific_namespace_rules [facultatif, défaut=None] :

Un objet (sous la forme {"namespace1":true/false, "namespace2":true/false}) qui permet d’activer ou de désactiver la collecte de métriques de certains espaces de nommage AWS, uniquement pour ce compte AWS. La liste des espaces de nommage est disponible dans l’endpoint /v1/integration/aws/available_namespace_rules.

SIGNATURE:

PUT /v1/integration/aws

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

# Update an AWS Account in Datadog

curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "filter_tags": [
            "<TAG_KEY>:<TAG_VALUE>"
        ],
        "host_tags": [
            "<TAG_KEY>:<TAG_VALUE>"
        ],
        "account_specific_namespace_rules": {
            "auto_scaling": false,
            "opsworks": false
        }
    }' \
"https://api.datadoghq.com/api/v1/integration/aws?account_id=<YOUR_AWS_ACCOUNT_ID>&role_name=<ROLE_NAME>"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}

Supprimer une intégration AWS

Supprimer une intégration Datadog/AWS donnée.

ARGUMENTS:

SIGNATURE:

DELETE /v1/integration/aws

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

# Delete an AWS Account in Datadog
curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "account_id": "<AWS_ACCOUNT_ID>",
        "role_name": "DatadogAWSIntegrationRole"
}' \
"https://api.datadoghq.com/api/v1/integration/aws"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}

Énumérer les règles d’espace de nommage

Énumérer toutes les règles d’espace de nommage pour une intégration Datadog/AWS donnée.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/integration/aws/available_namespace_rules

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

# List available namespace rules
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/aws/available_namespace_rules"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
["api_gateway","application_elb","appsync","auto_scaling","billing","budgeting","cloudfront","cloudsearch","cloudwatch_events","cloudwatch_logs","codebuild","collect_custom_metrics","crawl_alarms","ddos_protection","directconnect","dms","documentdb","dynamodb","ebs","ec2","ec2api","ec2spot","ecs","efs","elasticache","elasticbeanstalk","elastictranscoder","elb","emr","es","firehose","gamelift","iot","kinesis","kinesis_analytics","kms","lambda","lex","ml","mq","nat_gateway","network_elb","opsworks","polly","rds","redshift","rekognition","route53","s3","sagemaker","ses","sns","sqs","state_machine","storage_gateway","swf","vpn","waf","workspaces","xray"]

Générer des ID externes

Générer un nouvel ID externe AWS pour une paire compte AWS/nom de rôle donnée.

ARGUMENTS :

SIGNATURE :

PUT /v1/integration/aws/generate_new_external_id

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X PUT \
-H "Content-type: application/json"
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d
  '{
        "account_id": "<YOUR_AWS_ACCOUNT_ID>",
        "role_name": "DatadogAWSIntegrationRole"
    }' \
"https://dd.datadoghq.com/api/v1/integration/aws/generate_new_external_id"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Get list of AWS log ready services

Get the list of current AWS services that Datadog offers automatic log collection. Use returned service IDs with the services parameter for the Enable an AWS service log collection API endpoint.

ARGUMENTS:

This endpoint takes no JSON arguments.

SIGNATURE :

GET /v1/integration/aws/logs/services

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/aws/logs/services"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}

Ajouter l’ARN de Lambda pour les logs AWS

Attachez l’ARN du Lambda créé pour la collecte de logs AWS de Datadog à votre identifiant de compte AWS pour activer la collecte de logs.

ARGUMENTS:

SIGNATURE :

POST /v1/integration/aws/logs

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "account_id": "<AWS_ACCOUNT_ID>",
        "lambda_arn": "arn:aws:lambda:us-east-1:123456789012:function:PushLogs"
    }'\
"https://api.datadoghq.com/api/v1/integration/aws/logs"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}

Activer la collecte de logs d’un service AWS

Activez la collecte automatique de logs pour vos services AWS.

ARGUMENTS:

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

POST /v1/integration/aws/logs/services

EXAMPLE REQUEST:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X POST \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-H "Content-type: application/json" \
-d '{
        "account_id": "<AWS_ACCOUNT_ID>",
        "services": ["elb","s3"]
    }'\
"https://api.datadoghq.com/api/v1/integration/aws/logs/services"

EXAMPLE RESPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Delete AWS log collection

Delete a Datadog-AWS log collection configuration by removing the specific Lambda ARN associated with a given AWS account.

ARGUMENTS:

SIGNATURE :

DELETE /v1/integration/aws/logs

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "account_id": "<AWS_ACCOUNT_ID>",
        "lambda_arn": "arn:aws:lambda:us-east-1:123456789012:function:PushLogs"
    }'\
"https://api.datadoghq.com/api/v1/integration/aws/logs"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}

Intégration Azure

Les endpoints Azure ne sont pas pris en charge dans les bibliothèques client de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Configurez votre intégration Datadog/Azure directement avec l’API Datadog.
Pour en savoir plus, consultez la page de l’intégration Datadog/Azure.

Énumérer toutes les intégrations Azure

Énumérez toutes les intégrations Datadog/Azure configurées pour votre organisation.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/azure

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.get_integration('azure')
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/azure"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{
  "tenant_name" => "<AZURE_TENANT_NAME>",
  "errors" => [],
  "host_filters" => "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>",
  "client_id" => "<AZURE_CLIENT_ID>"
}
OK

Créer une intégration Azure

Créer une intégration Datadog/Azure.

Remarque :

  • La méthode POST permet de mettre à jour la configuration de votre intégration en ajoutant votre nouvelle configuration à celle de votre organisation Datadog.
  • La méthode PUT permet de mettre à jour la configuration de votre intégration en remplaçant votre configuration actuelle par une nouvelle, envoyée à votre organisation Datadog.

ARGUMENTS:

Consultez les instructions d’installation de l’intégration Datadog/Azure pour découvrir comment obtenir les valeurs des champs suivants pour votre organisation.

  • tenant_name [requis] :

    Votre ID Azure Active Directory.

  • client_id [requis] :

    Votre ID d’application Web Azure

  • client_secret [requis] :

    La clé de secret de votre application Web Azure.

  • host_filters [facultatif, défaut=None] :

    Limitez les instances Azure qui sont transmises à Datadog à l’aide de tags. Seuls les hosts qui correspondent à l’un des tags définis sont importés dans Datadog.

SIGNATURE:

POST /v1/integration/azure

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

config= {
    "tenant_name": "<AZURE_TENANT_NAME>",
    "client_id": "<AZURE_CLIENT_ID>",
    "client_secret": "<AZURE_CLIENT_SECRET>",
    "host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
  }

dog = Dogapi::Client.new(api_key, app_key)

dog.create_integration('azure', config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

# Create an Azure account in Datadog
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "tenant_name": "<AZURE_TENANT_NAME>",
        "client_id": "<AZURE_CLIENT_ID>",
        "client_secret": "<AZURE_CLIENT_SECRET>",
        "host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
    }' \
"https://api.datadoghq.com/api/v1/integration/azure"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Supprimer une intégration Azure

Supprimez une intégration Datadog/Azure donnée.

ARGUMENTS:

Consultez les instructions d’installation de l’intégration Datadog/Azure pour découvrir comment obtenir les valeurs des champs suivants pour votre organisation.

  • tenant_name [requis] :

    Votre ID Azure Active Directory.

  • client_id [requis] :

    Votre ID d’application Web Azure

  • host_filters [facultatif, défaut=None] :

    Limitez les instances Azure qui sont transmises à Datadog à l’aide de tags. Seuls les hosts qui correspondent à l’un des tags définis sont importés dans Datadog.

SIGNATURE :

DELETE /v1/integration/azure

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "tenant_name": "<AZURE_TENANT_NAME>",
        "client_id": "<AZURE_CLIENT_ID>"
    }' \
"https://api.datadoghq.com/api/v1/integration/azure"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
OK

Mettre à jour les filtres de host d’une intégration Azure

Mettez à jour la liste définie des filtres de host pour une intégration Datadog/Azure donnée.

ARGUMENTS:

Consultez les instructions d’installation de l’intégration Datadog/Azure pour découvrir comment obtenir les valeurs des champs suivants pour votre organisation.

  • tenant_name [requis] :

    Votre ID Azure Active Directory.

  • client_id [requis] :

    Votre ID d’application Web Azure

  • client_secret [requis] :

    La clé de secret de votre application Web Azure.

  • host_filters [facultatif, défaut=None] :

    Limitez les instances Azure qui sont transmises à Datadog à l’aide de tags. Seuls les hosts qui correspondent à l’un des tags définis sont importés dans Datadog.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

POST /v1/integration/azure/host_filters

EXAMPLE REQUEST:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

config= {
    "tenant_name": "<AZURE_TENANT_NAME>",
    "client_id": "<AZURE_CLIENT_ID>",
    "client_secret": "<AZURE_CLIENT_SECRET>",
    "host_filters": "<NEW_KEY>:<NEW_VALUE>"
  }

dog = Dogapi::Client.new(api_key, app_key)

dog.create_integration('azure', config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "tenant_name": "<AZURE_TENANT_NAME>",
        "client_id": "<AZURE_CLIENT_ID>",
        "client_secret": "<AZURE_CLIENT_SECRET>",
        "host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
    }' \
"https://api.datadoghq.com/api/v1/integration/azure/host_filters"

EXAMPLE RESPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Intégration GCP

Les endpoints GCP ne sont pas pris en charge dans les bibliothèques client de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Configurez votre intégration Datadog/Google Cloud Platform (GCP) directement avec l’API Datadog.
En savoir plus sur l’intégration Datadog/Google Cloud Platform.

Énumérer toutes les intégrations GCP

Énumérez toutes les intégrations Datadog/GCP configurées pour votre organisation.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/gcp

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.get_integration('gcp')
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/gcp"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{
  "automute" => false,
  "project_id" => "<GCP_PROJECT_ID>",
  "client_email" => "<CLIENT_EMAIL>",
  "errors" => [],
  "host_filters" => "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}
OK

Créer une intégration GCP

Créer une intégration Datadog/Google Cloud Platform.

Remarque :

  • La méthode POST permet de mettre à jour la configuration de votre intégration en ajoutant votre nouvelle configuration à celle de votre organisation Datadog.
  • La méthode PUT permet de mettre à jour la configuration de votre intégration en remplaçant votre configuration actuelle par une nouvelle, envoyée à votre organisation Datadog.

ARGUMENTS:

Toutes les valeurs des champs suivants sont fournies par le fichier de clé du compte de service JSON créé dans la console GCP des comptes de service. Consultez les instructions d’installation de l’intégration Datadog/Google Cloud Platform pour découvrir comment générer une clé pour votre organisation. Pour davantage d’informations, consultez la documentation relative au compte de service Google Cloud (en anglais).

  • type [obligatoire] :

La valeur de service_account indiquée dans la clé de votre compte de service JSON.

  • project_id [obligatoire] :

    L’ID de votre projet Google Cloud indiquée dans la clé de votre compte de service JSON.

  • private_key_id [obligatoire] :

    L’ID de votre clé privée indiquée dans la clé de votre compte de service JSON.

  • private_key [obligatoire] :

    Le nom de votre clé privée indiquée dans la clé de votre compte de service JSON.

  • client_email [obligatoire] :

    L’adresse e-mail indiquée dans la clé de votre compte de service JSON.

  • client_id [requis] :

    L’ID indiquée dans la clé de votre compte de service JSON.

  • auth_uri [obligatoire] :

    Doit être https://accounts.google.com/o/oauth2/auth.

  • token_uri [obligatoire] :

    Doit être https://accounts.google.com/o/oauth2/token.

  • auth_provider_x509_cert_url [obligatoire] :

    Doit être https://www.googleapis.com/oauth2/v1/certs.

  • client_x509_cert_url [obligatoire] :

    Doit être https://www.googleapis.com/robot/v1/metadata/x509/<E-MAIL_CLIENT>, où <E-MAIL_CLIENT> correspond à l’adresse e-mail indiquée dans la clé de votre compte de service JSON.

  • host_filters [facultatif] :

    Limite les instances GCE qui sont transmises à Datadog à l’aide de tags. Seuls les hosts qui correspondent à l’un des tags définis sont importés dans Datadog.

  • automute [facultatif, défaut=false] :

    Désactive les monitors lors des arrêts planifiés de l’instance GCE.

SIGNATURE :

POST /v1/integration/gcp

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

config= {
    "type": "service_account",
    "project_id": "<GCP_PROJECT_ID>",
    "private_key_id": "<PRIVATE_KEY_ID>",
    "private_key": "<PRIVATE_KEY>",
    "client_email": "<CLIENT_EMAIL>",
    "client_id": "<CLIENT_ID>",
    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
    "token_uri": "https://accounts.google.com/o/oauth2/token",
    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
    "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/<CLIENT_EMAIL>",
    "host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
  }

dog = Dogapi::Client.new(api_key, app_key)

dog.create_integration('gcp', config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "type": "service_account",
        "project_id": "<GCP_PROJECT_ID>",
        "private_key_id": "<PRIVATE_KEY_ID>",
        "private_key": "<PRIVATE_KEY>",
        "client_email": "<CLIENT_EMAIL>",
        "client_id": "<CLIENT_ID>",
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://accounts.google.com/o/oauth2/token",
        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
        "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/<CLIENT_EMAIL>",
        "host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
    }' \
"https://api.datadoghq.com/api/v1/integration/gcp"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Supprimer une intégration GCP

Supprimez une intégration Datadog/GCP donnée.

ARGUMENTS:

  • project_id [requis] :

    L’ID de votre projet Google Cloud indiquée dans la clé de votre compte de service JSON.

  • client_email [obligatoire] :

    L’adresse e-mail indiquée dans la clé de votre compte de service JSON.

SIGNATURE:

DELETE /v1/integration/gcp

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X DELETE \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "project_id": "<GCP_PROJECT_ID>",
        "client_email": "<CLIENT_EMAIL>"
    }' \
"https://api.datadoghq.com/api/v1/integration/gcp"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
OK

Définir la désactivation automatique de l’intégration GCP

Activez ou annulez la désactivation automatique pour une intégration Datadog/GCP donnée.

ARGUMENTS:

  • project_id [requis] :

    L’ID de votre projet Google Cloud indiquée dans la clé de votre compte de service JSON.

  • client_email [obligatoire] :

    L’adresse e-mail indiquée dans la clé de votre compte de service JSON.

  • automute [facultatif, défaut=false] :

    Désactive les monitors lors des arrêts planifiés de l’instance GCE.

SIGNATURE:

PUT /v1/integration/gcp

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

config= {
  "project_id": "<GCP_PROJECT_ID>",
  "client_email": "<CLIENT_EMAIL>",
  "automute": false
}

dog = Dogapi::Client.new(api_key, app_key)

dog.update_integration('gcp', config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "project_id": "<GCP_PROJECT_ID>",
        "client_email": "<CLIENT_EMAIL>",
        "automute": <AUTOMUTE>
    }' \
"https://api.datadoghq.com/api/v1/integration/gcp"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Intégration PagerDuty

Les endpoints PagerDuty ne sont pas pris en charge dans la bibliothèque Python client. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Configurez votre intégration Datadog/PagerDuty directement avec l’API Datadog.
Pour en savoir plus, consultez la page sur l’intégration Datadog/PagerDuty.

Obtenir une intégration PagerDuty

Obtenez toutes les informations sur votre intégration Datadog/PagerDuty.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/pagerduty

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.get_integration('pagerduty')
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/pagerduty"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{
  "services" => [{
    "service_name" => "<SERVICE_NAME_1>",
    "service_key" => "*****"
  }, {
    "service_name" => "<SERVICE_NAME_2>",
    "service_key" => "*****"
  }], "schedules" => ["<SCHEDULE_1>", "<SCHEDULE_2>"],
  "subdomain" => "<PAGERDUTY_SUB_DOMAIN>",
  "api_token" => "*****"
}
OK

Créer une intégration PagerDuty

Créez une intégration Datadog/PagerDuty.

Remarque : tous les arguments sont requis lors de la création (PUT) d’une configuration PagerDuty.

ARGUMENTS:

  • services : Le tableau des objets de service PagerDuty. Découvrez comment configurer votre service Datadog avec la documentation de PagerDuty. Un objet de service PagerDuty est composé de ce qui suit :

    • service_name [obligatoire] : Le nom de votre service dans PagerDuty.

    • service_key [obligatoire] : La clé de service associée au nom de votre service dans Pagerduty.

  • subdomain : Le nom du sous-domaine personnalisé de votre compte PagerDuty.

  • schedules : Tableau de vos URL programmées, par ex. : ["https://my-pd.pagerduty.com/schedules#PCPYT4M", "https://my-pd.pagerduty.com/schedules#PKTPB7P"]

  • api_token : Votre token d’API PagerDuty.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

PUT /v1/integration/pagerduty

EXAMPLE REQUEST:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

config= {
    "services": [
      {
        "service_name": "<SERVICE_NAME_1>",
        "service_key": "<PAGERDUTY_SERVICE_KEY>"
      },
      {
        "service_name": "<SERVICE_NAME_2>",
        "service_key": "<PAGERDUTY_SERVICE_KEY>"
      }
    ],
    "subdomain": "<PAGERDUTY_SUB_DOMAIN>",
    "schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
    "api_token": "<PAGERDUTY_TOKEN>"
  }

dog = Dogapi::Client.new(api_key, app_key)

dog.create_integration('pagerduty', config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "services": [
        {
          "service_name": "<SERVICE_NAME_1>",
          "service_key": "<PAGERDUTY_SERVICE_KEY>"
        },
        {
          "service_name": "<SERVICE_NAME_2>",
          "service_key": "<PAGERDUTY_SERVICE_KEY>"
        }
      ],
      "subdomain": "<PAGERDUTY_SUB_DOMAIN>",
      "schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
      "api_token": "<PAGERDUTY_TOKEN>"
  }' \
"https://api.datadoghq.com/api/v1/integration/pagerduty"

EXAMPLE RESPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Ajout de nouveaux services et calendriers

Ajoutez de nouveaux services et calendriers à votre intégration Datadog/PagerDuty.

ARGUMENTS:

  • services : Le tableau des objets de service PagerDuty. Découvrez comment configurer votre service Datadog avec la documentation de PagerDuty. Un objet de service PagerDuty est composé de :

    • service_name [obligatoire] : Le nom de votre service dans PagerDuty.

    • service_key [obligatoire] : La clé de service associée au nom de votre service dans Pagerduty.

  • schedules : Le tableau des URL de vos calendriers : ["https://my-pd.pagerduty.com/schedules#PCPYT4M", "https://my-pd.pagerduty.com/schedules#PKTPB7P"]

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

POST /v1/integration/pagerduty

EXAMPLE REQUEST:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

config= {
    "services": [
      {
        "service_name": "test_00",
        "service_key": "<PAGERDUTY_SERVICE_KEY>"
      },
      {
        "service_name": "test_01",
        "service_key": "<PAGERDUTY_SERVICE_KEY>"
      }
    ],
    "schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
}

dog = Dogapi::Client.new(api_key, app_key)

dog.update_integration('pagerduty', config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "services": [
        {
          "service_name": "test_00",
          "service_key": "<PAGERDUTY_SERVICE_KEY>"
        },
        {
          "service_name": "test_01",
          "service_key": "<PAGERDUTY_SERVICE_KEY>"
        }
      ],
      "schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
  }' \
"https://api.datadoghq.com/api/v1/integration/pagerduty"

EXAMPLE RESPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Supprimer une intégration PagerDuty

Supprimez l’intégration Datadog/PagerDuty.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

DELETE /v1/integration/pagerduty

EXAMPLE REQUEST:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.delete_integration('pagerduty')
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/pagerduty"

EXAMPLE RESPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Intégration Slack

Les endpoints Slack ne sont pas pris en charge dans la bibliothèque Python de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Configurez votre intégration Datadog/Slack directement avec l’API Datadog.
Pour en savoir plus sur l’intégration Datadog/Slack, consultez la page d’intégration.

Obtenir l’intégration Slack

Obtenez toutes les informations sur votre intégration Datadog/Slack.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/slack

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.get_integration('slack')
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/slack"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{
  "channels" => [], "service_hooks" => [{
    "url" => "*****",
    "account" => "Main_Account"
  }, {
    "url" => "*****",
    "account" => "doghouse"
  }]
}
OK

Créer une intégration Slack

Créez une intégration Datadog-Slack. Une fois crée, ajoutez-y des canaux avec l’endpoint Ajouter des canaux Slack.

Remarque :

  • La méthode POST permet de mettre à jour la configuration de votre intégration en ajoutant votre nouvelle configuration à celle de votre organisation Datadog.
  • La méthode PUT permet de mettre à jour la configuration de votre intégration en remplaçant votre configuration actuelle par une nouvelle, envoyée à votre organisation Datadog.

ARGUMENTS:

  • service_hooks [obligatoire] : Tableau d’objets de hook de service (le hook de service est généré pour votre compte dans votre page d’administration Slack). Un objet de hook de service est composé des éléments suivants :

    • account [obligatoire] : Le nom de votre compte Slack.

    • url [obligatoire] : L’URL de votre hook de service Slack.

Remarque : les service_hooks ne sont pas requis dans la charge utile lors de l’ajout (POST) ou la mise à jour (PUT) d’une configuration de Slack existante.

SIGNATURE:

POST /v1/integration/slack

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

config= {
    "service_hooks": [
      {
        "account": "Main_Account",
        "url": "https://hooks.slack.com/services/1/1/1"
      },
      {
        "account": "doghouse",
        "url": "https://hooks.slack.com/services/2/2/2"
      }
    ]
  }

dog = Dogapi::Client.new(api_key, app_key)

dog.create_integration('slack', config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
    "service_hooks": [
      {
        "account": "Main_Account",
        "url": "https://hooks.slack.com/services/1/1/1"
      },
      {
        "account": "doghouse",
        "url": "https://hooks.slack.com/services/2/2/2"
      }
    ]
  }' \
"https://api.datadoghq.com/api/v1/integration/slack"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Add channels to Slack integration

Add channels to your Datadog-Slack integration.

ARGUMENTS:

  • channels [required]: The array of slack channel objects to post to. A slack channel object is composed by:

    • channel_name [required]: Your channel name e.g: #general, #private

    • transfer_all_user_comments [optional, default=False]: To be notified for every comment on a graph, set it to true. If set to False use the @slack-channel_name syntax for comments to be posted to slack.

    • account [required]: Account to which the channel belongs to.

SIGNATURE:

POST /v1/integration/slack

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

config= {
  "channels": [
      {
        "channel_name": "#channel_name_main_account",
        "transfer_all_user_comments": "false",
        "account": "Main_Account"
      },
      {
        "channel_name": "#channel_name_doghouse",
        "transfer_all_user_comments": "false",
        "account": "doghouse"
      }
  ]
}

dog = Dogapi::Client.new(api_key, app_key)

dog.update_integration('slack', config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
    "channels": [
        {
          "channel_name": "#channel_name_main_account",
          "transfer_all_user_comments": "false",
          "account": "Main_Account"
        },
        {
          "channel_name": "#channel_name_doghouse",
          "transfer_all_user_comments": "false",
          "account": "doghouse"
        }
    ]
}' \
"https://api.datadoghq.com/api/v1/integration/slack"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Supprimer une intégration Slack

Supprimez une intégration Datadog/Slack.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

DELETE /v1/integration/slack

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.delete_integration('slack')
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/slack"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Intégration Webhooks

Les endpoints de webhook ne sont pas pris en charge dans la bibliothèque Python de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Configurez votre intégration Datadog/Webhooks directement avec l’API Datadog. Pour en savoir plus sur l’intégration Datadog/Webhooks, consultez la page d’intégration.

Obtenir une intégration Webhooks

Obtenez toutes les informations sur l’intégration Datadog/Webhooks.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/webhooks

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.get_integration('webhooks')
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/webhooks"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{
  "hooks" => [{
    "custom_payload" => "",
    "name" => "Example",
    "url" => "http://example.com",
    "encode_as_form" => "false",
    "headers" => "",
    "use_custom_payload" => "false"
  }]
}
OK

Créer une intégration Webhooks

Créez une intégration Datadog/Webhooks.

Remarque :

  • La méthode POST permet de mettre à jour la configuration de votre intégration en ajoutant votre nouvelle configuration à celle de votre organisation Datadog.

ARGUMENTS :

  • hooks [obligatoire] : Tableau d’objets Webhook. Un objet Webhook est composé de :

    • name [obligatoire] : Le nom de votre Webhook. Découvrez comment l’utiliser dans des notifications de monitor.
    • url [obligatoire] : L’URL de votre Webhook.
    • use_custom_payload [facultatif, défaut=False] : Si défini sur true, vous permet de spécifier une charge utile personnalisée pour votre Webhook.

    • custom_payload [facultatif, défaut=None] : Si use_custom_payload est défini sur true, spécifiez votre propre charge utile pour ajouter vos propres champs personnalisés à la requête en utilisant ces variables.

    • encode_as_form [facultatif, défaut=False] : si use_custom_payload est défini sur true, définissez ce paramètre sur true pour encoder votre charge utile dans une URL.

    • headers [facultatif, défaut=None] : En-têtes attachés à votre Webhook.

SIGNATURE:

POST /v1/integration/webhooks

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

config= {
    "hooks": [
      {
        "name": "Example",
        "url": "http://example.com"
      }
    ]
}

dog = Dogapi::Client.new(api_key, app_key)

dog.create_integration('webhooks', config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
    "hooks": [
      {
        "name": "<WEBHOOK_NAME>",
        "url": "<WEBHOOK_URL>"
      }
    ]
}' \
"https://api.datadoghq.com/api/v1/integration/webhooks"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Mettre à jour une intégration Webhooks

Ajoutez un Webhook spécifique à une intégration Datadog/Webhooks.

ARGUMENTS :

  • hooks [obligatoire] : tableau d’objets Webhook. Un objet Webhook est composé de :

    • name [obligatoire] : le nom de votre Webhook. Découvrez comment l’utiliser dans les notifications de monitor.
    • url [obligatoire] : l’URL de votre Webhook.
    • use_custom_payload [facultatif, défaut=False] : si défini sur true, vous permet de spécifier une charge utile personnalisée pour votre Webhook.

    • custom_payload [facultatif, défaut=None] : si use_custom_payload est défini sur true, spécifiez votre propre charge utile pour ajouter vos propres champs personnalisés à la requête en utilisant ces variables.

    • encode_as_form [facultatif, défaut=False] : si use_custom_payload est défini sur true, définissez ce paramètre sur true pour encoder votre charge utile dans une URL.

    • headers [facultatif, défaut=None] : en-têtes associés à votre Webhook.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

POST /v1/integration/webhooks

EXAMPLE REQUEST:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

config= {
    "hooks": [
      {
        "name": "Example",
        "url": "http://example.com/2"
      }
    ]
}

dog = Dogapi::Client.new(api_key, app_key)

dog.update_integration('webhooks', config)
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
    "hooks": [
      {
        "name": "<WEBHOOK_NAME>",
        "url": "<WEBHOOK_URL>"
      }
    ]
}' \
"https://api.datadoghq.com/api/v1/integration/webhooks"

EXAMPLE RESPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Supprimer une intégration Webhooks

Supprimez une intégration Datadog/Webhooks donnée.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

DELETE /v1/integration/webhooks

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.delete_integration('webhooks')
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -v -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/integration/webhooks"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
{}
OK

Gestion des clés

Les endpoints de gestion des clés ne sont pas pris en charge dans les bibliothèques client de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Gérez vos clés d’application et d’API Datadog.

Vous avez besoin d’une clé d’API et d’application ainsi que de droits administrateur pour interagir avec cet endpoint.

La liste complète des clés est visible sur votre page Datadog API.

Obtenir toutes les clés d’API

Obtenez toutes les clés d’API disponibles pour votre compte.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/api_key/

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/api_key"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "api_keys": [
        {
            "created_by": "john@example.com",
            "name": "<API_KEY_NAME>",
            "key": "1111111111111111aaaaaaaaaaaaaaaa",
            "created": "2019-04-05 09:20:30"
        },
        {
            "created_by": "jane@example.com",
            "name": "<APP_KEY_NAME_2>",
            "key": "2111111111111111aaaaaaaaaaaaaaaa",
            "created": "2019-04-05 09:19:53"
        }
    ]
}

Obtenir une clé d’API

Obtenez une clé d’API spécifique.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/api_key/<CLÉ_API>

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/api_key/<API_KEY_TO_GET>"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "api_key": {
        "created_by": "john@example.com",
        "name": "<API_KEY_NAME>",
        "key": "3111111111111111aaaaaaaaaaaaaaaa",
        "created": "2019-04-05 09:47:00"
    }
}

Créer une clé d’API

Créer une clé d’API avec un nom donné.

ARGUMENTS :

  • name [obligatoire] :

Le nom de votre clé d’API.

SIGNATURE :

POST /v1/api_key/<CLÉ_API>

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X POST \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
	      "name": "<API_KEY_NAME>"
    }' \
"https://app.datadoghq.com/api/v1/api_key"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "api_key": {
        "created_by": "john@example.com",
        "name": "<API_KEY_NAME>",
        "key": "3111111111111111aaaaaaaaaaaaaaaa",
        "created": "2019-04-05 09:47:00"
    }
}

Modifier une clé d’API

Modifier le nom d’une clé d’API.

ARGUMENTS :

  • name [obligatoire] :

Le nom de votre clé d’API.

SIGNATURE :

PUT /v1/api_key/<CLÉ_API>

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "name":"<NEW_API_KEY_NAME>"
    }' \
"https://app.datadoghq.com/api/v1/api_key/<API_KEY_TO_EDIT>"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "api_key": {
        "created_by": "john@example.com",
        "name": "<API_KEY_NAME>",
        "key": "3111111111111111aaaaaaaaaaaaaaaa",
        "created": "2019-04-05 09:47:00"
    }
}

Supprimer une clé d’API

Supprimez une clé d’API donnée.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

DELETE /v1/api_key/<CLÉ_API>

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X DELETE \
-H 'Content-Type: application/json'
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/api_key/<API_KEY_TO_DELETE>"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "api_key": {
        "created_by": "john@example.com",
        "name": "<API_KEY_NAME>",
        "key": "3111111111111111aaaaaaaaaaaaaaaa",
        "created": "2019-04-05 09:47:00"
    }
}

Obtenir toutes les clés d’application

Obtenez toutes les clés d’application disponibles pour votre compte.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/application_key/

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/application_key"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "application_keys": [
        {
            "owner": "john@example.com",
            "hash": "11111111111111111111aaaaaaaaaaaaaaaaaaaa",
            "name": "<APP_KEY_NAME>"
        },
        {
            "owner": "jane@example.com",
            "hash": "21111111111111111111aaaaaaaaaaaaaaaaaaaa",
            "name": "<APP_KEY_NAME_2>"
        }
    ]
}

Obtenir une clé d’application

Obtenez une clé d’application spécifique.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/application_key/<CLÉ_APP>

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/application_key/<APP_KEY_TO_GET>"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "application_key": {
        "owner": "john@example.com",
        "hash": "31111111111111111111aaaaaaaaaaaaaaaaaaaa",
        "name": "<APP_KEY_NAME>"
    }
}

Créer une clé d’application

Créer une clé d’application avec un nom donné.

ARGUMENTS :

  • name [obligatoire] :

    Le nom de votre clé d’application.

SIGNATURE :

POST /v1/application_key/<CLÉ_APPLICATION>

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X POST \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
	      "name": "<APP_KEY_NAME>"
    }' \
"https://app.datadoghq.com/api/v1/application_key"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "application_key": {
        "owner": "john@example.com",
        "hash": "31111111111111111111aaaaaaaaaaaaaaaaaaaa",
        "name": "<APP_KEY_NAME>"
    }
}

Modifier une clé d’application

Modifier le nom d’une clé d’application.

ARGUMENTS :

  • name [obligatoire] :

Le nom de votre clé d’application.

SIGNATURE :

PUT /v1/application_key/<CLÉ_APPLICATION>

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "name":"<NEW_APP_KEY_NAME>"
    }' \
"https://app.datadoghq.com/api/v1/application_key/<APP_KEY_TO_EDIT>"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "application_key": {
        "owner": "john@example.com",
        "hash": "31111111111111111111aaaaaaaaaaaaaaaaaaaa",
        "name": "<NEW_APP_KEY_NAME>"
    }
}

Supprimer une clé d’application

Supprimez une clé d’application donnée.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

DELETE /v1/application_key/<CLÉ_APPLICATION>

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X DELETE \
-H 'Content-Type: application/json'
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://app.datadoghq.com/api/v1/application_key/<APP_KEY_TO_DELETE>"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "application_key": {
        "owner": "john@example.com",
        "hash": "31111111111111111111aaaaaaaaaaaaaaaaaaaa",
        "name": "<APP_KEY_NAME>"
    }
}

Logs

Les endpoints des logs ne sont pas pris en charge dans les bibliothèques client de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Envoyez vos logs à votre plateforme Datadog par HTTP. Les limites par requête HTTP sont les suivantes :

  • Taille maximale du contenu par charge utile : 5 Mo
  • Taille maximale d’un log : 256 Ko
  • Taille maximale d’un tableau en cas d’envoi de plusieurs logs dans un tableau : 500 entrées

Remarque : si vous utilisez le site européen de Datadog (app.datadoghq.eu), l’endpoint HTTP des logs est le suivant : https://http-intake.logs.datadoghq.eu.

Envoyer des logs via HTTP

ÉlémentDescription
Protocolehttp : 80
https : 443
HostPour le site Datadog américain : http-intake.logs.datadoghq.com
Pour le site Datadog européen : http-intake.logs.datadoghq.eu
Chemin/v1/input/<CLÉ_API_DATADOG>
Paramètres de la requêteLes paramètres de requête disponibles sont l’attribut de log réservé. ?ddtags=<TAGS>&ddsource=<SOURCE>&service=<SERVICE>&hostname=<HOSTNAME>
MéthodePOST
Type de contenuLes types de contenu suivants sont disponibles : text/plain, application/json, application/logplex-1

SIGNATURE:

https://http-intake.logs.datadoghq.com/v1/input/<CLÉ_API_DATADOG>

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
## Simple Raw Message
## Log attributes can be passed as query parameters

curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY>?ddtags=env:prod,user:my-user \
     -H "Content-Type: text/plain" \
     -d 'hello world'

## Multi Raw Messages

curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
     -H "Content-Type: text/plain" \
     --data-binary @- <<BODY
hello
world
BODY

## Simple JSON Message
## Log attributes can also be passed as key:value pairs in valid JSON messages
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
     -H "Content-Type: application/json" \
     -d '{"message":"hello world", "ddsource":"<SOURCE>", "ddtags":"env:<ENV>,user:<USER_NAME>", "hostname":"<HOSTNAME>"}'

## Multi JSON Messages

curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
     -H "Content-Type: application/json" \
     --data-binary @- <<BODY
[
  {
    "message": "hello"
  },
  {
    "message": "world"
  }
]
BODY

## Simple Logplex Message

curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
     -H "Content-Type: application/logplex-1" \
     -d 'hello world'

## Multi Logplex Messages

curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
     -H "Content-Type: application/logplex-1" \
     --data-binary @- <<BODY
hello
world
BODY

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}

Récupérer la liste des logs

Le endpoint List renvoie les logs qui correspondent à une requête de recherche de log. Les résultats sont paginés.

Si vous songez à archiver des logs pour votre organisation, nous vous conseillons d’utiliser les fonctionnalités d’archivage de Datadog plutôt que l’API Log List. Consultez la documentation sur l’archivage de logs Datadog.

ARGUMENTS:

  • query [obligatoire] : requête de recherche respectant la syntaxe de recherche de log.
  • time.from [obligatoire] : timestamp minimal pour les logs demandés. Sa valeur peut correspondre à l’un des formats suivants :
    • Une chaîne ISO-8601
    • Un timestamp unix (un nombre représentant le nombre de millisecondes écoulées depuis epoch)
    • Une heure relative (now -10m, now - 1h, now - 1d)
  • time.to [obligatoire] : timestamp maximal pour les logs demandés. Sa valeur peut correspondre à l’un des formats suivants :
    • Une chaîne ISO-8601 à la minute, seconde ou milliseconde près
    • Un timestamp unix (un nombre représentant le nombre de millisecondes écoulées depuis epoch)
    • Une heure relative (now, now -10m, now - 1h, now - 1d)
  • time.timezone [facultatif, défaut=None] : peut être spécifié sous la forme d’un décalage (p. ex., « UTC+03:00 ») ou d’un indicatif régional (p. ex., « Europe/Paris »).
  • time.offset [facultatif, défaut=None] : correspond à time.timezone, mais avec une valeur en secondes. Si vous spécifiez à la fois un fuseau horaire et un décalage, le fuseau horaire est ignoré.
  • startAt [facultatif, défaut=None] : l’identificateur de hachage du premier log à renvoyer dans la liste, disponible dans l’attribut id du log. Ce paramètre est utilisé pour la fonctionnalité de pagination. Remarque : ce paramètre est ignoré lorsque le log correspondant n’est pas inclus dans l’intervalle spécifié.
  • sort [facultatif, défaut=desc] : résultats dans l’ordre chronologique croissant (asc) ou décroissant (desc).
  • limit [facultatif, défaut=10] : nombre de logs renvoyés dans la réponse (maximum : 1 000).
  • index [facultatif, défaut=main] : pour les organisations avec plusieurs index, l’index de log sur lequel la requête porte.

SIGNATURE:

POST api/v1/logs-queries/list

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X POST \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{ 
        "query": "service:nginx -@http.method:POST",
        "time": {
            "from": "now - 1h",
            "to": "now"
        },
        "sort": "desc",
        "limit": 50
    }' \
"https://api.datadoghq.com/api/v1/logs-queries/list"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    logs: [{
        id: "AAAAAWgN8Xwgr1vKDQAAAABBV2dOOFh3ZzZobm1mWXJFYTR0OA",
        content: {
            timestamp: "2019-01-02T09:42:36.320Z",
            tags: ['team:A'],
            attributes: {
                customAttribute: 123,
                duration: 2345
            },
            host: 'i-123',
            service: 'agent',
            message: 'host connected to remote'
        }
    }],
    nextLogId: "BBBBWgn...",
    status: "ok"
}

Index de logs

Cet endpoint est en bêta public et n'est pas pris en charge par les bibliothèques client de Datadog. Si vous souhaitez nous faire part de vos remarques, contactez l'assistance Datadog.

L’objet Index décrit la configuration d’un index de log. Voici ses attributs :

  • name (lecture seule) : nom de l’index.
  • filter.query : seuls les logs qui correspondent aux critères du filtre sont pris en compte pour cet index. requête de recherche respectant la syntaxe de recherche de log.
  • num_retention_days (lecture seule) : nombre de jours avant la suppression des logs de cet index.
  • daily_limit (lecture seule) : nombre d’événements de log que vous pouvez envoyer avant d’atteindre les limites de débit.
  • is_rate_limited (lecture seule) : valeur booléenne précisant si l’index a atteint sa limite de débit, ce qui signifie qu’un nombre de logs supérieur à la limite quotidienne a été envoyé. La limite de débit est réinitialisée tous les jours à 14 h UTC.
  • exclusion_filters : tableau d’objets ExclusionFilter (voir ci-après). Les logs sont testés avec la requête de chaque ExclusionFilter, en suivant l’ordre défini dans le tableau. Seul le premier ExclusionFilter actif correspondant est pris en compte, les éventuels autres filtres sont ignorés.

    • name : nom du filtre d’exclusion.
    • is_enabled : valeur booléenne précisant si l’exclusion est active (ce qui entraîne l’exclusion des logs) ou non.
    • filter.query : seuls les logs qui correspondent aux critères du filtre ET à la requête de l’index parent seront pris en compte pour ce filtre d’exclusion. La requête de recherche respecte la syntaxe de recherche de log.
    • filter.sample_rate : pourcentage de logs exclus par le filtre d’exclusion, lorsque celui-ci est actif. L’échantillonnage est uniforme.

Remarque : vous avez besoin d’une clé d’API et d’application ainsi que de droits administrateur pour interagir avec cet endpoint.

Obtenir tous les index

Cet endpoint est en bêta public. Si vous souhaitez nous faire part de vos remarques, contactez l'assistance Datadog.

Cet endpoint renvoie un tableau des objets Index de votre organisation.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/logs/config/indexes/

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/indexes"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
  "indexes": [
      {
        "name": "<INDEX_NAME>",
        "filter": {
            "query": "<INDEX_FILTER_QUERY>"
        },
        "num_retention_days": 15,
        "daily_limit": 150000000,
        "is_rate_limited": false,
        "exclusion_filters": [
            {
                "name": "<INDEX_EXCLUSTION_FILTER_1>",
                "is_enabled": true,
                "filter": {
                    "query": "<INDEX_EXCLUSTION_FILTER_QUERY>",
                    "sample_rate": 1
                }
            }
        ]
    }
  ]
}

Obtenir un index

Cet endpoint est en bêta public. Si vous souhaitez nous faire part de vos remarques, contactez l'assistance Datadog.

Cet endpoint renvoie un Index identifié par son nom.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/logs/config/indexes/<NOM_INDEX>

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/indexes/<INDEX_NAME>"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
	"name": "<INDEX_NAME>",
	"filter": {
		"query": "<INDEX_FILTER_QUERY>"
	},
	"num_retention_days": 15,
	"daily_limit": 150000000,
	"is_rate_limited": false,
	"exclusion_filters": [
		{
			"name": "<INDEX_EXCLUSTION_FILTER_1>",
			"is_enabled": true,
			"filter": {
				"query": "<INDEX_EXCLUSTION_FILTER_QUERY>",
				"sample_rate": 1
			}
		}
	]
}

Mettre à jour un index

Cet endpoint est en bêta public. Si vous souhaitez nous faire part de vos remarques, contactez l'assistance Datadog.

Cet endpoint met à jour un Index identifié par son nom. Il renvoie l’objet Index passé dans le corps de la requête lorsque celle-ci est réussie.

ARGUMENTS :

Remarque : la méthode PUT permet de mettre à jour la configuration de votre index en remplaçant votre configuration actuelle par la nouvelle, envoyée à votre organisation Datadog.

  • filter.query [facultatif] : seuls les logs qui correspondent aux critères du filtre sont pris en compte pour cet index. La requête de recherche respecte la syntaxe de recherche de logs
  • exclusion_filters : un tableau d’objets ExclusionFilter (voir ci-après). Les logs sont testés avec la requête de chaque ExclusionFilter, en suivant l’ordre défini dans le tableau. Seul le premier ExclusionFilter actif qui correspond est pris en compte, les éventuels autres sont ignorés. L’objet ExclusionFilter décrit la configuration d’un filtre d’exclusion. Ses attributs sont les suivants :

    • name [obligatoire] : nom du filtre d’exclusion.
    • is_enabled [facultatif, défaut=False] : valeur booléenne précisant si l’exclusion est active ou non.
    • filter.query [facultatif] : seuls les logs qui correspondent aux critères du filtre ET à la requête de l’index parent sont pris en compte pour ce filtre d’exclusion. La requête de recherche respecte la syntaxe de recherche de logs
    • filter.sample_rate [obligatoire] : pourcentage de logs exclus par le filtre d’exclusion, lorsque celui-ci est actif. L’échantillonnage est uniforme.

SIGNATURE:

PUT /v1/logs/config/indexes/<NOM_INDEX>

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X PUT \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
    "filter": {
        "query": "<NEW_INDEX_FILTER_QUERY>"
    },
    "exclusion_filters": [
      {
        "name": "<INDEX_EXCLUSTION_FILTER_1>",
        "is_enabled": true,
        "filter": {
          "query": "<INDEX_EXCLUSTION_FILTER_QUERY>",
          "sample_rate": 1
        }
      },
      {
        "name": "<INDEX_EXCLUSTION_FILTER_2>",
        "is_enabled": true,
        "filter": {
          "query": "<INDEX_EXCLUSTION_FILTER_QUERY_2>",
          "sample_rate": 1
        }
      }
    ]
}' \
"https://api.datadoghq.com/api/v1/logs/config/indexes/<INDEX_NAME>"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
	"name": "<INDEX_NAME>",
	"filter": {
		"query": "<NEW_INDEX_FILTER_QUERY>"
	},
	"num_retention_days": 15,
	"daily_limit": 150000000,
	"is_rate_limited": false,
	"exclusion_filters": [
		{
        "name": "<INDEX_EXCLUSTION_FILTER_1>",
        "is_enabled": true,
        "filter": {
          "query": "<INDEX_EXCLUSTION_FILTER_QUERY>",
          "sample_rate": 1
        }
      },
      {
        "name": "<INDEX_EXCLUSTION_FILTER_2>",
        "is_enabled": true,
        "filter": {
          "query": "<INDEX_EXCLUSTION_FILTER_QUERY_2>",
          "sample_rate": 1
        }
      }
	]
}

Obtenir la séquence des index

Cet endpoint est en bêta public. Si vous souhaitez nous faire part de vos remarques, contactez l'assistance Datadog.

Utilisez les endpoints de séquence des index pour contrôler la séquence de processing des index d’une organisation. Utilisez cet endpoint uniquement si vous avez plus d’un index de logs dans votre organisation. Notez que cet index ne peut pas être utilisé pour ajouter ou supprimer des index.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/logs/config/index-order

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/index-order"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
	"index_names": [
		"<INDEX_NAME_1>",
		"<INDEX_NAME_2>"
	]
}

Mettre à jour la séquence des index

Cet endpoint est en bêta public. Si vous souhaitez nous faire part de vos remarques, contactez l'assistance Datadog.

Ce endpoint met à jour le IndexOrder de votre organisation. Il renvoie l’objet IndexOrder passé dans le corps de la requête lorsque celle-ci est réussie.

ARGUMENTS:

  • index_names [required] : Tableau de Strings identifiant par leur nom les index de votre organisation. Les logs sont testés un par un par rapport au filtre de requête de chaque index, en suivant l’ordre du tableau. Les logs sont finalement stockés dans le premier index correspondant.

SIGNATURE:

PUT /v1/logs/config/index-order

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X PUT \
-H 'content-type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
	"index_names": [
    "<INDEX_NAME_2>",
		"<INDEX_NAME_1>"
	]
}' \
"https://api.datadoghq.com/api/v1/logs/config/index-order"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
	"index_names": [
        "<INDEX_NAME_2>",
		"<INDEX_NAME_1>"
	]
}

Pipelines de logs

Les endpoints Pipelines de logs ne sont pas pris en charge dans les bibliothèques client de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Les pipelines et les processeurs fonctionnent sur les logs entrants, effectuant le parsing et la transformation de ces derniers en attributs structurés pour faciliter les requêtes.

Remarque : ces endpoints sont uniquement disponibles pour les utilisateurs admin. Veillez à utiliser une clé d’application créée par un admin.

Obtenir la séquence des pipelines

Obtenir la séquence actuelle de vos pipelines.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/logs/config/pipeline-order

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/pipeline-order"

EXEMPLE DE RÉPONSE:

Mettre à jour la séquence des pipelines

Mettez à jour la séquence de vos pipelines. Les logs étant traités de manière séquentielle, la réorganisation d’un pipeline peut changer la structure et le contenu des données traitées par les autres pipelines et leurs processeurs.

Remarque : la méthode PUT permet de mettre à jour la séquence de vos pipelines en remplaçant votre séquence actuelle par la nouvelle, envoyée à votre organisation Datadog.

ARGUMENTS :

  • pipeline_ids [obligatoire] : un tableau ordonné de chaînes <ID_PIPELINE>. L’ordre des identifiants de pipeline dans le tableau définit l’ordre de traitement des pipelines par Datadog.

SIGNATURE:

PUT /v1/logs/config/pipeline-order

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
    "pipeline_ids": [
        "<PIPELINE_1_ID>",
        "<PIPELINE_2_ID>",
        "<PIPELINE_3_ID>"
    ]
}' \
"https://api.datadoghq.com/api/v1/logs/config/pipeline-order"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "pipeline_ids": [
        "<PIPELINE_1_ID>",
        "<PIPELINE_2_ID>",
        "<PIPELINE_3_ID>"
    ]
}

Obtenir toutes les pipelines

Obtenez tous les pipelines de votre organisation.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/logs/config/pipelines

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/pipelines"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
[
    {
        "id": "<PIPELINE_1_ID>",
        "type": "pipeline",
        "name": "<PIPELINE_1_NAME>",
        "is_enabled": false,
        "is_read_only": true,
        "filter": {
            "query": "<PIPELINE_1_FILTER>"
        },
        "processors": ["<PROCESSOR_PIPELINE_1ARRAY>"
        ]
    },
    {
        "id": "<PIPELINE_2_ID>",
        "type": "pipeline",
        "name": "<PIPELINE_2_NAME>",
        "is_enabled": false,
        "is_read_only": true,
        "filter": {
            "query": "<PIPELINE_2_FILTER>"
        },
        "processors": ["<PROCESSOR_PIPELINE_2_ARRAY>"
        ]
    }
]

Obtenir un pipeline

Obtenez un pipeline spécifique de votre organisation.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/logs/config/pipelines/<ID_PIPELINE>

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>
pipeline_id=<PIPELINE_ID>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/${pipeline_id}"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "id": "<PIPELINE_ID>",
    "type": "pipeline",
    "name": "<PIPELINE_NAME>",
    "is_enabled": false,
    "is_read_only": true,
    "filter": {
        "query": "<PIPELINE_FILTER>"
    },
    "processors": [
        {
            "name": "<PROCESSOR_1_NAME>",
            "is_enabled": true,
            "source": "message",
            "grok": {
                "support_rules": "",
                "match_rules": "<MATCHED_RULES>"
            },
            "type": "grok-parser"
        },
        {
            "name": "Define timestamp as the official timestamp of the log",
            "is_enabled": true,
            "sources": [
                "timestamp"
            ],
            "type": "date-remapper"
        },
        {
            "name": "Define level as the official log status",
            "is_enabled": true,
            "sources": [
                "level"
            ],
            "type": "status-remapper"
        }
    ]
}

Créer un pipeline

Créez un pipeline dans votre organisation.

ARGUMENTS:

  • name [obligatoire] : Le nom de votre pipeline.

  • is_enabled [facultatif, défaut=False] : Valeur booléenne permettant d’activer votre pipeline.

  • filter.query [facultatif] : définit le filtre de votre pipeline. Seuls les logs correspondant aux critères du filtre sont traités par ce pipeline.

  • processors [facultatif] : un tableau ordonné de processeurs ou pipelines imbriqués. Consultez la documentation relative au processeur pour connaître le schémas spécifique à chaque processeur.

SIGNATURE:

POST /v1/logs/config/pipelines

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>

curl -X POST \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
    "name": "<PIPELINE_NAME>",
    "is_enabled": true,
    "filter": {
        "query": "<PIPELINE_QUERY>"
    },
    "processors": [
        {
            "name": "Define date as the official timestamp of the log",
            "is_enabled": true,
            "sources": [
                "date"
            ],
            "type": "date-remapper"
        }
    ]
}' \
"https://api.datadoghq.com/api/v1/logs/config/pipelines"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "id": "7fKHTENgSkyGoJcCDbem-g",
    "type": "pipeline",
    "name": "<PIPELINE_NAME>",
    "is_enabled": true,
    "is_read_only": false,
    "filter": {
        "query": "<PIPELINE_QUERY>"
    },
    "processors": [
        {
            "name": "Define date as the official timestamp of the log",
            "is_enabled": true,
            "sources": [
                "date"
            ],
            "type": "date-remapper"
        }
    ]
}

Mettre à jour un pipeline

Mettez à jour une configuration de pipeline donnée pour modifier ses processeurs ou leur ordre.

ARGUMENTS:

Remarque : la méthode PUT permet de mettre à jour la configuration de votre pipeline en remplaçant votre configuration actuelle par la nouvelle, envoyée à votre organisation Datadog.

  • name [obligatoire] : Le nom de votre pipeline.

  • is_enabled [facultatif, défaut=False] : Valeur booléenne permettant d’activer votre pipeline.

  • filter.query [facultatif] : définit le filtre de votre pipeline. Seuls les logs correspondant aux critères du filtre sont traités par ce pipeline.

  • processors [facultatif] : un tableau séquentiel de processeurs ou pipelines imbriqués. Consultez la documentation relative au processeur pour obtenir le schéma spécifique à chaque processeur.

SIGNATURE:

PUT /v1/logs/config/pipelines/<ID_PIPELINE>

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>
pipeline_id=<PIPELINE_ID>

curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
    "name": "<NEW_PIPELINE_NAME>",
    "is_enabled": true,
    "filter": {
        "query": "<NEW_PIPELINE_QUERY>"
    },
    "processors": [
        {
            "name": "Define date as the official timestamp of the log",
            "is_enabled": true,
            "sources": [
                "date"
            ],
            "type": "date-remapper"
        }
    ]
}' \
"https://api.datadoghq.com/api/v1/logs/config/pipelines/${pipeline_id}"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "id": "<PIPELINE_ID>",
    "type": "pipeline",
    "name": "<NEW_PIPELINE_NAME>",
    "is_enabled": true,
    "is_read_only": false,
    "filter": {
        "query": "<NEW_PIPELINE_QUERY>"
    },
    "processors": [
        {
            "name": "Define date as the official timestamp of the log",
            "is_enabled": true,
            "sources": [
                "date"
            ],
            "type": "date-remapper"
        }
    ]
}

Supprimer un pipeline

Supprimez un pipeline donné de votre organisation.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

DELETE /v1/logs/config/pipelines

EXEMPLE DE REQUÊTE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account

api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>
pipeline_id=<PIPELINE_ID>

curl -X DELETE \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/logs/config/pipelines/${pipeline_id}"

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}

Métriques

L’endpoint métrique vous permet de :

  • Envoyez vos données de métriques afin de les afficher sur les dashboards de Datadog.
  • Interroger les métriques de n’importe quelle période

Comme dans l’interface utilisateur de Datadog, un graphique ne peut contenir qu’un nombre défini de points. Lorsque la durée d’affichage d’une métrique augmente, les points sont agrégés afin de ne pas dépasser ce nombre.

Ainsi, si vous interrogez des intervalles de données plus grands, les points renvoyés sont davantage agrégés. Dans Datadog, la granularité maximale est d’un point par seconde. Ainsi, si vous avez envoyé des points à cet intervalle et que vous avez demandé un très petit intervalle auprès de l’API de requête (ici, probablement moins de 100 secondes), vous pouvez récupérer tous ces points. Sinon, l’algorithme Datadog essaie de renvoyer environ 150 points par intervalle donné, de sorte que vous observerez une granularité de moins en moins précise à mesure que la durée demandée augmente. Cette agrégation temporelle repose sur un système de moyennes.

Nous conservons les points de métrique à une résolution d’une seconde, mais nous vous recommandons d’envoyer des points seulement toutes les 15 secondes. Toutes les métriques avec des timestamps composés de fractions d’une seconde sont arrondies à la seconde la plus proche. Si plusieurs points possèdent le même timestamp, le dernier point remplace les précédents.

Une imite souple de 100 séries temporelles par host s’applique. Une série temporelle représente une combinaison unique d’un tag et d’un nom d’une métrique.

Récupérer la liste des métriques actives

Cet endpoint n’est pas pris en charge dans la bibliothèque client Ruby de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Obtenez la liste des métriques de reporting actives depuis une date précise. Cet endpoint n’est pas disponible dans les bibliothèques Python et Ruby.

ARGUMENTS:

  • from [obligatoire] : secondes depuis l’epoch Unix
  • host [facultatif] : le hostname qui permet de filtrer la liste des métriques renvoyées. Si ce paramètre est défini, les métriques récupérées sont celles avec le tag de hostname correspondant.

SIGNATURE:

GET /v1/metrics

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Taking the last 24hours
from_time = int(time.time()) - 60 * 60 * 24 * 1

result = api.Metric.list(from_time)

print(result)
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example 
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

from_time=$((date +%s - 86400))

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d "from=${from_time}" \
-d "host=<HOSTNAME>" \
"https://api.datadoghq.com/api/v1/metrics"

EXEMPLE DE RÉPONSE:

{
    "metrics": [
        "system.load.1",
        "system.load.15",
        "system.load.5",
        "system.load.norm.1",
        "system.load.norm.15",
        "system.load.norm.5",
        "system.mem.buffered",
        "system.mem.cached",
        "system.mem.committed",
        "system.mem.free"
    ],
    "from": 1467815773
}
{
    "metrics": [
        "system.load.1",
        "system.load.15",
        "system.load.5",
        "system.load.norm.1",
        "system.load.norm.15",
        "system.load.norm.5",
        "system.mem.buffered",
        "system.mem.cached",
        "system.mem.committed",
        "system.mem.free"
    ],
    "from": 1467815773
}
{
  "metrics": [
    "system.load.1",
    "system.load.15",
    "system.load.5",
    "system.load.norm.1",
    "system.load.norm.15",
    "system.load.norm.5",
    "system.mem.buffered",
    "system.mem.cached",
    "system.mem.committed",
    "system.mem.free"
  ],
  "from": 1467815773
}

Envoyer des points de séries temporelles

L’endpoint de métrique vous permet d’envoyer des données de séries temporelles pouvant être représentées graphiquement sur les dashboards de Datadog. La limite des charges utiles compressées est de 3,2 mégaoctets (3 200 000), tandis que celle des charges utiles décompressées est de 62 mégaoctets (62 914 560).

Poids des données :

Si vous envoyez directement des métriques à l’API Datadog sans utiliser DogStatsD, attendez-vous à :

  • 64 bits pour le timestamp
  • 64 bits pour la valeur
  • 20 octets pour les noms de métriques
  • 50 octets pour les séries temporelles

La charge utile totale pèse environ 100 octets. Cependant, avec l’API DogStatsD, cette charge est compressée afin de réduire son poids.

ARGUMENTS :

  • series [obligatoire] : transmet un tableau JSON pour lequel chaque élément contient les arguments suivants :

    • metric [obligatoire] : le nom de la série temporelle.
    • type [facultatif, défaut=gauge] : le type de votre métrique : gauge, rate ou count.
    • interval [facultatif, défaut=None] : si le type de la métrique est rate ou count, définissez l’intervalle correspondant.
    • points [obligatoire] : un tableau de points JSON. Chaque point suit le format suivant : [[timestamp_POSIC, valeur_numérique], ...] Remarque : le timestamp doit être exprimé en secondes et sa valeur doit être actuelle. Le format de la valeur numérique doit être une valeur flottante de type gauge 32 bits. Une valeur actuelle correspond à une date jusqu’à 1 heure avant l’événement et jusqu’à 10 minutes après celui-ci.
    • host [facultatif] : le nom du host qui a généré la métrique.
    • tags [facultatif, défaut=None] : la liste de tags associés à la métrique.

SIGNATURE:

POST /v1/series

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<YOUR_API_KEY>'
}

initialize(**options)

now = time.time()
future_10s = now + 10

# Submit a single point with a timestamp of `now`
api.Metric.send(metric='page.views', points=1000)

# Submit a point with a timestamp (must be ~current)
api.Metric.send(metric='my.pair', points=(now, 15))

# Submit multiple points.
api.Metric.send(
    metric='my.series',
    points=[
        (now, 15),
        (future_10s, 16)
    ]
)

# Submit a point with a host and tags.
api.Metric.send(
    metric='my.series',
    points=100,
    host="myhost.example.com",
    tags=["version:1"]
)

# Submit multiple metrics
api.Metric.send([{
    'metric': 'my.series',
    'points': 15
}, {
    'metric': 'my1.series',
    'points': 16
}])
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'

dog = Dogapi::Client.new(api_key)

# Submit one metric value.
dog.emit_point('some.metric.name', 50.0, :host => "my_host.example.com")

# Submit multiple metric values
points = [
    [Time.now, 0],
    [Time.now + 10, 10.0],
    [Time.now + 20, 20.0]
]
dog.emit_points('some.metric.name', points, :tags => ["version:1"])

# Emit differents metrics in a single request to be more efficient
dog.batch_metrics do
  dog.emit_point('test.api.test_metric',10)
  dog.emit_point('test.api.this_other_metric', 1)
end


currenttime=$(date +%s)

curl  -X POST -H "Content-type: application/json" \
-d "{ \"series\" :
         [{\"metric\":\"test.metric\",
          \"points\":[[$currenttime, 20]],
          \"type\":\"rate\",
          \"interval\": 20,
          \"host\":\"test.example.com\",
          \"tags\":[\"environment:test\"]}
        ]
}" \
"https://api.datadoghq.com/api/v1/series?api_key=<YOUR_API_KEY>"

Interroger les points de séries temporelles

Cet endpoint vous permet d’interroger des métriques sur la période de votre choix. Utilisez la syntaxe de requête décrite dans la section De la requête au graphique.

Remarque : en Python, from est un mot réservé. À la place, l’API Python utilise les paramètres start et end dans l’appel de la fonction.

ARGUMENTS:

  • from [obligatoire, sauf en Python] : secondes depuis l’epoch unix.
  • to [obligatoire, sauf en Python] : secondes depuis l’epoch unix.
  • start [obligatoire en Python, défaut=None] : secondes depuis l’epoch unix.
  • end [obligatoire en Python, défaut=None] : secondes depuis l’epoch unix.
  • query [obligatoire] : la chaîne de requête.

SIGNATURE:

GET /v1/query

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

now = int(time.time())

query = 'system.cpu.idle{*}by{host}'
print api.Metric.query(start=now - 3600, end=now, query=query)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Get points from the last hour
from = Time.now - 3600
to = Time.now
query = 'system.cpu.idle{*}by{host}'

dog.get_points(query, from, to)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
to_time=$(date +%s)
from_time=$(date --date='1 day ago' +%s)

curl -X GET \
    -H "DD-API-KEY: ${api_key}" \
    -H "DD-APPLICATION-KEY: ${app_key}" \
    "https://api.datadoghq.com/api/v1/query?&query=avg:system.cpu.user\{*\}by\{host\}&from=${from_time}&to=${to_time}"

EXEMPLE DE RÉPONSE:

{
    'status': 'ok',
    'res_type': 'time_series',
    'series': [{
        'end': 1430313599000,
        'metric': 'system.cpu.idle',
        'interval': 30,
        'start': 1430312070000,
        'length': 10,
        'aggr': None,
        'attributes': {},
        'pointlist': [
            [1430312070000.0, 75.08000183105469],
            [1430312100000.0, 99.33000183105469],
            [1430312130000.0, 99.83499908447266],
            [1430312160000.0, 100.0],
            [1430312190000.0, 99.66999816894531],
            [1430312220000.0, 100.0],
            [1430312250000.0, 99.83499908447266],
            [1430312280000.0, 99.66999816894531],
            [1430312310000.0, 99.83499908447266],
            [1430312340000.0, 99.66999816894531]
        ],
        'expression': 'system.cpu.idle{host:vagrant-ubuntu-trusty-64}',
        'scope': 'host:vagrant-ubuntu-trusty-64',
        'unit': None,
        'display_name': 'system.cpu.idle'
    }],
    'from_date': 1430309983000,
    'group_by': ['host'],
    'to_date': 1430313583000,
    'query': 'system.cpu.idle{*}by{host}',
    'message': u''
}
{
    'status' => 'ok',
    'res_type' => 'time_series',
    'series' => [{
        'end' => 1430313599000,
        'metric' => 'system.cpu.idle',
        'interval' => 30,
        'start' => 1430312070000,
        'length' => 10,
        'aggr' => nil,
        'attributes' => {},
        'pointlist' => [
            [1430312070000.0, 75.08000183105469],
            [1430312100000.0, 99.33000183105469],
            [1430312130000.0, 99.83499908447266],
            [1430312160000.0, 100.0],
            [1430312190000.0, 99.66999816894531],
            [1430312220000.0, 100.0],
            [1430312250000.0, 99.83499908447266],
            [1430312280000.0, 99.66999816894531],
            [1430312310000.0, 99.83499908447266],
            [1430312340000.0, 99.66999816894531]
        ],
        'expression' => 'system.cpu.idle{host:vagrant-ubuntu-trusty-64}',
        'scope' => 'host:vagrant-ubuntu-trusty-64',
        'unit' => nil,
        'display_name' => 'system.cpu.idle'
    }],
    'from_date' => 1430309983000,
    'group_by' => ['host'],
    'to_date' => 1430313583000,
    'query' => 'system.cpu.idle{*}by{host}',
    'message' => ''
}
{
  "status": "ok",
  "res_type": "time_series",
  "series": [
    {
      "metric": "system.cpu.idle",
      "attributes": {},
      "display_name": "system.cpu.idle",
      "unit": null,
      "pointlist": [
        [
          1430311800000,
          98.19375610351562
        ],
        [
          1430312400000,
          99.85856628417969
        ]
      ],
      "end": 1430312999000,
      "interval": 600,
      "start": 1430311800000,
      "length": 2,
      "aggr": null,
      "scope": "host:vagrant-ubuntu-trusty-64",
      "expression": "system.cpu.idle{host:vagrant-ubuntu-trusty-64}"
    }
  ],
  "from_date": 1430226140000,
  "group_by": [
    "host"
  ],
  "to_date": 1430312540000,
  "query": "system.cpu.idle{*}by{host}",
  "message": ""
}

Afficher les métadonnées d’une métrique

L’endpoint des métadonnées de métriques vous permet d’obtenir des métadonnées sur une métrique spécifique.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/metrics/<NOM_MÉTRIQUE>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

metric = 'system.cpu.idle'

api.Metadata.get(metric_name=metric)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Get metadata on metric
result = dog.get_metadata('system.net.bytes_sent')

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

metric_name="system.net.bytes_sent"

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/metrics/${metric_name}"

EXEMPLE DE RÉPONSE:

{
    'description': 'Percent of time the CPU spent in an idle state.',
    'short_name': 'cpu idle',
    'integration': 'system',
    'statsd_interval': None,
    'per_unit': None,
    'type': 'gauge',
    'unit': 'percent'
}
{
 	"description" => "Percent of time the CPU spent in an idle state.",
 	"short_name" => "cpu idle",
 	"integration" => "system",
 	"statsd_interval" => nil,
 	"per_unit" => nil,
 	"type" => "gauge",
 	"unit" => "percent"
}
{
  "description": "My custom description",
  "short_name":"bytes sent",
  "integration": null,
  "statsd_interval": null,
  "per_unit": "second",
  "type": "gauge",
  "unit": "byte"
}

Modifier les métadonnées d’une métrique

L’endpoint des métadonnées de métriques vous permet de modifier les champs des métadonnées d’une métrique. En savoir plus sur les différents types pris en charge.

ARGUMENTS:

  • type [obligatoire] : type de la métrique, p. ex. gauge ou rate.
  • description [facultatif, défaut=None] : description de la chaîne de caractères de la métrique par défaut.
  • short_name [obligatoire] : nom raccourci de la métrique.
  • unit [facultatif, défaut=None] : unité primaire de la métrique, p. ex. byte ou operation.
  • per_unit [facultatif, défaut=None] : unité secondaire de la métrique, p. ex. seconde pour octets par seconde.
  • statsd_interval [facultatif, défaut=None] : le cas échéant, statds transmet l’intervalle en secondes pour la métrique.

SIGNATURE:

PUT /v1/metrics/<NOM_MÉTRIQUE>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

metric = 'system.net.bytes_sent'
params = {
    'description': 'My custom description',
    'short_name': 'bytes sent',
    'type': 'gauge',
    'unit': 'byte',
    'per_unit': 'second'
}

api.Metadata.update(metric_name=metric, **params)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

updates = {
    "type" => "gauge",
    "description" => "my custom description",
    "short_name" => "bytes sent",
    "unit" => "byte",
    "per_unit" => "second"
}

# Submit updates for metric
result = dog.update_metadata('system.net.bytes_sent', updates)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

metric_name="system.net.bytes_sent"

curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "type": "gauge",
      "description": "my custom description",
      "short_name": "bytes sent",
      "unit": "byte",
      "per_unit": "second"
}' \
"https://api.datadoghq.com/api/v1/metrics/${metric_name}"

EXEMPLE DE RÉPONSE:

{
    'description': 'My custom description',
    'short_name': 'bytes sent',
    'integration': None,
    'statsd_interval': None,
    'per_unit': 'second',
    'type': 'gauge',
    'unit': 'byte'
}
{
 	"description" => "My custom description",
 	"short_name" => "bytes sent",
 	"integration" => nil,
 	"statsd_interval" => nil,
 	"per_unit" => "second",
 	"type" => "gauge",
 	"unit" => "byte"
}
{
  "description": "my custom description",
  "short_name": "bytes sent",
  "integration": null,
  "statsd_interval": null,
  "per_unit": "second",
  "type": "gauge",
  "unit": "byte"
}

Rechercher des métriques

Cet endpoint vous permet de rechercher des métriques parmi celles recueillies au cours des dernières 24 heures dans Datadog.

ARGUMENTS:

  • q [obligatoire] : la chaîne de requête utilisée pour la recherche de métriques. Doit commencer par metrics:

Remarque : le préfixe host: est également pris en charge pour rechercher des hostnames, mais il est maintenant obsolète. Utilisez l’endpoint de recherche de host à la place.

SIGNATURE:

GET /v1/search

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for the Datadog API
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

dog.search("metrics:test")
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d "api_key=${api_key}" \
-d "application_key=${app_key}" \
"https://api.datadoghq.com/api/v1/search?q=metrics:aws"

EXEMPLE DE RÉPONSE:


{
    'results': {
        'metrics': [
            'test.metric.metric',
            'test.tag.metric'
        ]
    }
}
["200", {
    "results" => {
        "metrics" => ["test.metric"]
    }
}]
{
  "results": {
    "metrics": [
      "test.metric"
    ]
  }
}

Monitors

Les monitors vous permettent de surveiller une métrique ou un check pertinent, en envoyant une notification à votre équipe lorsque certains seuils définis sont dépassés. Reportez-vous à la page Creating Monitors pour en savoir plus sur la création de monitors.

Créer un monitor

Si vous programmez la gestion et le déploiement des monitors, vous pouvez définir plus facilement le monitor dans l’IU Datadog et exporter son JSON valide.

ARGUMENTS:

  • type [obligatoire] : le type de monitor. Vous trouverez sous-dessous les différentes valeurs autorisées :
Type de monitorValeur de l’attribut du type
anomalyquery alert
apmquery alert
compositecomposite
customservice check
eventevent alert
forecastquery alert
hostservice check
integrationquery alert ou service check
live processprocess alert
logslog alert
metricmetric alert
networkservice check
outlierquery alert
processservice check
watchdogevent alert
  • query [obligatoire] : le paramètre query définit à quel moment le monitor se déclenche. La syntaxe de la requête dépend du type de monitor que vous créez :

    Requête d’alerte de métrique

    time_aggr(time_window):space_aggr:metric{tags} [by {key}] operator #

    • time_aggr : avg, sum, max, min, change ou pct_change.
    • time_window : last_#m (où # doit être remplacé par 5, 10, 15 ou 30), last_#h (où # doit être remplacé par 1, 2 ou 4) ou last_1d.
    • space_aggr : avg, sum, min ou max.
    • tags : un ou plusieurs tags (séparés par des virgules) ou *.
    • key : la ‘key’ de la syntaxe de tags key:value. Définit une alerte distincte pour chaque tag du groupe (alertes multiples).
    • operator : <, <=, >, >=, == ou !=.
    • # : un nombre entier ou un chiffre décimal utilisé pour définir le seuil.

    Si vous utilisez l’agrégateur temporel _change_ ou _pct_change_, utilisez plutôt change_aggr(time_aggr(time_window), timeshift):space_aggr:metric{tags} [by {key}] operator # avec :

    • change_aggr : change, pct_change.
    • time_aggr : avg, sum, max, min. En savoir plus.
    • time_window last_#m (1, 5, 10, 15 ou 30), last_#h (1, 2 ou 4) ou last_#d (1 ou 2)
    • timeshift : #m_ago (5, 10, 15 ou 30), #h_ago (1, 2 ou 4) ou 1d_ago.

    Utilisez ce paramètre pour créer un monitor outlier à l’aide de la requête suivante : avg(last_30m):outliers(avg:system.cpu.user{role:es-events-data} by {host}, 'dbscan', 7) > 0.

    Requête de check de service

    "check".over(tags).last(count).count_by_status()

    • check : nom du check, par exemple datadog.agent.up.
    • tags : un ou plusieurs tags entre guillemets (séparés par des virgules) ou « * ». Exemple : .over("env:prod", "role:db").
    • count doit être >= à votre seuil maximum (défini dans options). Par exemple, si vous souhaitez recevoir une notification à partir de 1 statut Critical, 3 statuts Ok et 2  statuts Warning, « count » doit prendre pour valeur 3. La valeur maximale est de 10.
    Requête d’alerte d’événement

    events('sources:nagios status:error,warning priority:normal tags: "string query"').rollup("count").last("1h")"

    • event : la chaîne de requête de l’événement.
    • string_query : requête en texte libre à comparer au titre et au texte de l’événement.
    • sources : sources des événements (séparées par des virgules). Liste complète des valeurs d’attributs source.
    • status : statuts des événements (séparés par des virgules). Valeurs autorisées : error, warn et info.
    • priority : priorités des événements (séparées par des virgules). Valeurs autorisées : low, normal ou all.
    • host : hosts de transmission d’événements (séparés par des virgules).
    • tags : tags d’événement (séparés par des virgules).
    • excluded_tags : tags des événements exclus (séparés par des virgules).
    • rollup : la méthode de cumulation des statistiques. count est actuellement la seule méthode prise en charge.
    • last : l’intervalle pour cumuler les totaux. Exemples : 60 s, 4 h. Unités de temps prises en charge : s, m, h et j.
    Requête d’alerte de processus

    processes(search).over(tags).rollup('count').last(timeframe) operator #

    • search : recherche en texte libre pour interroger les processus. Les processus correspondants correspondent aux résultats de la page Live Processes.
    • **tags** : un ou plusieurs tags (séparés par des virgules).
    • timeframe : l’intervalle pour cumuler les totaux. Exemples : 60 s, 4 h. Unités de temps prises en charge : s, m, h et j
    • operator : <, <=, >, >=, == ou !=.
    • # : un nombre entier ou un chiffre décimal utilisé pour définir le seuil.
    Requête de composite

    12345 && 67890, où 12345 et 67890 sont les identifiants de monitors non composites.

  • name [obligatoire, défaut=valeur dynamique, basée sur la requête] : le nom de l’alerte.

  • message [obligatoire, défaut=valeur dynamique, basée sur la requête] : un message à inclure avec les notifications pour ce monitor. Les notifications par e-mail peuvent être envoyées à des utilisateurs spécifiques en utilisant la même notation « @nomutilisateur » que les événements.

  • tags [facultatif, défaut=liste vide] : la liste de tags à associer à votre monitor. Lorsque vous obtenez tous les détails du monitor via l’API, utilisez l’argument monitor_tags pour filtrer les résultats avec ces tags. Ces valeurs ne peuvent être utilisées qu’avec l’API et ne sont ni visibles ni modifiables dans l’IU Datadog.

  • options [facultatif, défaut={}] : un dictionnaire d’options pour le monitor. Certaines options sont couramment utilisées pour tous les types, tandis que d’autres sont spécifiques à certains types de monitors.

    Options couramment utilisées
    • silenced : dictionnaire de contextes caractérisés par des timestamps ou la valeur None. Chaque contexte est désactivé jusqu’au timestamp POSIX. Les contextes peuvent également être définitivement désactivés avec la valeur None. Valeur par défaut : None. Exemples :

      • Pour désactiver complètement l’alerte : {'*': None}.
      • Pour désactiver role:db à court terme : {'role:db': 1412798116}.
    • new_host_delay : durée (en secondes) autorisée pour le démarrage d’un host et le lancement complet des applications avant le début de l’évaluation des résultats du monitor. Doit être un nombre entier non négatif. Valeur par défaut : 300.

    • notify_no_data : une valeur booléenne qui indique si ce monitor envoie une notification en absence de transmission de données. Valeur par défaut : false.

    • no_data_timeframe : le nombre de minutes avant qu’un monitor envoie une notification en l’absence de transmission de données. Ce paramètre est obligatoire lorsque notify_no_data​ est défini sur true. Il doit correspondre au moins au double de l’intervalle du monitor pour les alertes de métrique, ou à 2 minutes pour les checks de service. Valeur par défaut : le double de l’intervalle pour les alertes de métrique, 2 minutes pour les checks de service.

    • timeout_h : le nombre d’heures durant lesquelles le monitor ne transmet pas les données avant qu’il ne procède à une résolution automatique à partir d’un état déclenché. Valeur par défaut : None.

    • require_full_window : une valeur booléenne indiquant si ce monitor a besoin d’une période complète de données avant son évaluation. Nous vous recommandons fortement de définir ce paramètre sur False pour les métriques creuses, sans quoi certaines évaluations sont ignorées. Valeur par défaut : True pour les agrégations « on average », « at all times » et « in total ». Pour les autres cas, False.

    • renotify_interval : le nombre de minutes après la dernière notification avant qu’un monitor envoie à nouveau une notification sur le statut actuel. La notification est uniquement envoyée s’il le monitor n’est pas résolu. Valeur par défaut : None.

    • escalation_message : le message à inclure avec la nouvelle notification. Prend en charge la syntaxe ‘@username’ utilisée ailleurs. Non applicable si renotify_interval est défini sur None. Valeur par défaut : None.

    • notify_audit : une valeur booléenne qui indique si les utilisateurs tagués sont informés des modifications apportées à ce monitor. Valeur par défaut : False.

    • locked : une valeur booléenne qui indique si uniquement le créateur ou les administrateurs peuvent apporter des modifications. Valeur par défaut : False.

    • include_tags : une valeur booléenne qui indique si les notifications de ce monitor insèrent automatiquement les tags à l’origine du déclenchement dans le titre. Valeur par défaut : True. Exemples :

      • True : [Triggered on {host:h1}] Titre du monitor
      • False: [Triggered] Titre du monitor
    Options d’anomalie

    Ces options s’appliquent uniquement aux monitors d’anomalie et sont ignorées pour les autres types de monitors.

    • threshold_windows : un dictionnaire contenant recovery_window et trigger_window.

      • recovery_window désigne la durée pendant laquelle une métrique anormale doit afficher un comportement normal pour que l’alerte soit annulée.
      • trigger_window désigne la durée pendant laquelle une métrique doit afficher un comportement anormal pour que l’alerte soit déclenchée.

      Exemple : {'threshold_windows': {'recovery_window': 'last_15m', 'trigger_window': 'last_15m'}}

    Options d’alerte de métrique

    Ces options s’appliquent uniquement aux alertes de métrique.

    • thresholds : un dictionnaire de seuils par type de seuil. Il existe deux types de seuils pour les alertes de métrique : critical et warning. Critical est défini dans la requête, mais peut également être précisé dans cette option. Le seuil warning peut uniquement être spécifié à l’aide de l’option thresholds. Si vous souhaitez appliquer des seuils de rétablissement à votre monitor, utilisez les attributs critical_recovery et warning_recovery.

    Exemple : {'critical': 90, 'warning': 80, 'critical_recovery': 70, 'warning_recovery': 50}.

    • evaluation_delay : durée (en secondes) correspondant au délai avant l’évaluation (nombre entier non négatif). Par exemple, pour une valeur définie sur 300 (5 min), si l’intervalle est défini sur last_5m et s’il est 7 h, le monitor évalue les données de 6 h 50 à 6 h 55. Cette option s’avère très utile pour AWS CloudWatch et pour d’autres métriques renvoyées pour s’assurer que le monitor dispose toujours de données lors de l’évaluation.
    Options de check de service

    Ces options s’appliquent uniquement aux checks de service et sont ignorées pour les autres types de monitors.

    • thresholds : un dictionnaire de seuils par statut. Comme les checks de service peuvent avoir plusieurs seuils, nous ne les définissons pas directement dans la requête.

    Exemple : {'ok': 1, 'critical': 1, 'warning': 1}

    Erreurs et validation
    • Si une option de monitor non valide fait partie de la requête, la réponse sera :

    Error: 400 - ["Invalid monitor option:<option non valide>"]

SIGNATURE:

POST /v1/monitor

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Create a new monitor
monitor_options = {
    "notify_no_data": True,
    "no_data_timeframe": 20
}
tags = ["app:webserver", "frontend"]
api.Monitor.create(
    type="metric alert",
    query="avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
    name="Bytes received on host0",
    message="We may need to add web hosts if this is consistently high.",
    tags=tags,
    options=monitor_options
)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Create a new monitor
options = {
    'notify_no_data' => true,
    'no_data_timeframe' => 20
}
tags = ['app:webserver', 'frontend']
dog.monitor("metric alert", "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100", :name => "Bytes received on host0", :message => "We may need to add web hosts if this is consistently high.", :tags => tags, :options => options)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "type": "metric alert",
      "query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high.",
      "tags": ["app:webserver", "frontend"],
      "options": {
      	"notify_no_data": true,
      	"no_data_timeframe": 20
      }
}' \
"https://api.datadoghq.com/api/v1/monitor"

EXEMPLE DE RÉPONSE:

{'creator': {'email': 'matt@example.com',
             'handle': 'matt@example.com',
             'id': 1896,
             'name': u'Matt'},
 'id': 2081,
 'message': 'We may need to add web hosts if this is consistently high.',
 'name': 'Bytes received on host0',
 'tags': ['app:webserver', 'frontend'],
 'options': {'no_data_timeframe': 20,
             'notify_audit': False,
             'notify_no_data': True,
             'silenced': {}},
 'org_id': 2,
 'overall_state': 'No Data',
 'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
 'type': 'metric alert',
 'multi': False,
 'created': '2015-12-18T16:34:14.014039+00:00',
 'modified': '2015-12-18T16:34:14.014039+00:00'
 }
["200", {
    "name" => "Bytes received on host0",
    "org_id" => 1499,
    "tags" => ["app:webserver", "frontend"],
    "options" => {
        "notify_no_data" => true,
        "no_data_timeframe" => 20,
        "notify_audit" => false,
        "silenced" => {}
    },
    "state" => {},
    "query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
    "message" => "We may need to add web hosts if this is consistently high.",
    "type" => "metric alert",
    "id" => 92089,
    "multi" => false,
    "created" => "2015-12-18T16:34:14.014039+00:00",
    "modified" => "2015-12-18T16:34:14.014039+00:00"
}]
{
  "id": 92090,
  "message": "We may need to add web hosts if this is consistently high.",
  "name": "Bytes received on host0",
  "tags": ["app:webserver", "frontend"],
  "options": {
    "no_data_timeframe": 20,
    "notify_audit": false,
    "notify_no_data": true,
    "silenced": {}
  },
  "org_id": 1499,
  "query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
  "state": {},
  "type": "metric alert",
  "multi": false,
  "created": "2015-12-18T16:34:14.014039+00:00",
  "modified": "2015-12-18T16:34:14.014039+00:00"
}

Récupérer les détails d’un monitor

ARGUMENTS:

  • group_states [facultatif, défaut=None] : Si cet argument est défini, les données renvoyées comprennent d’éventuelles informations supplémentaires concernant les états des groupes spécifiés, notamment le timestamp de la dernière notification, le timestamp de la dernière résolution et les détails du dernier déclenchement du monitor. L’argument doit inclure une liste de chaînes de caractères indiquant, le cas échéant, les états de groupe à inclure. Choisissez une ou plusieurs des valeurs suivantes : all, alert, warn ou no data. Exemple : alert,warn.

SIGNATURE:

GET /v1/monitor/<ID_MONITOR>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Get a monitor's details
api.Monitor.get(2081, group_states='all')
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Get a monitors's details
dog.get_monitor(91879, :group_states => 'all')
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
monitor_id=<YOUR_MONITOR_ID>

# Show a monitor
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d "group_states=all" \
"https://api.datadoghq.com/api/v1/monitor/${monitor_id}"

EXEMPLE DE RÉPONSE:

{
    'id': 2081,
    'message': 'We may need to add web hosts if this is consistently high.',
    'name': 'Bytes received on host0',
    'options': {
        'no_data_timeframe': 20,
        'notify_audit': False,
        'notify_no_data': True,
        'silenced': {}
    },
    'org_id': 2,
    'overall_state': 'No Data',
    'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
    'type': 'metric alert',
    'multi': False,
    'created': '2015-12-18T16:34:14.014039+00:00',
    'modified': '2015-12-18T16:34:14.014039+00:00',
    "state": {
        "groups": {
            "host:host0": {
                "last_nodata_ts": null,
                "last_notified_ts": 1481909160,
                "last_resolved_ts": 1481908200,
                "last_triggered_ts": 1481909160,
                "name": "host:host0",
                "status": "Alert",
                "triggering_value": {
                    "from_ts": 1481909037,
                    "to_ts": 1481909097,
                    "value": 1000
                }
            }
        }
    }
}
["200", {
    "name" => "Bytes received on host0",
    "org_id" => 1499,
    "options" => {
        "no_data_timeframe" => 20,
        "notify_no_data" => false,
        "notify_audit" => false,
        "silenced" => {}
    },
    "query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
    "message" => "We may need to add web hosts if this is consistently high.",
    "type" => "metric alert",
    "id" => 91879,
    "multi" => false,
    "created" => "2015-12-18T16:34:14.014039+00:00",
    "modified" => "2015-12-18T16:34:14.014039+00:00",
    "state" => {
        "groups" => {
            "host:host0" => {
                "last_nodata_ts" => null,
                "last_notified_ts" => 1481909160,
                "last_resolved_ts" => 1481908200,
                "last_triggered_ts" => 1481909160,
                "name" => "host:host0",
                "status" => "Alert",
                "triggering_value" => {
                    "from_ts" => 1481909037,
                    "to_ts" => 1481909097,
                    "value" => 1000
                }
            }
        }
    }
}]

{
  "id": 91879,
  "message": "We may need to add web hosts if this is consistently high.",
  "name": "Bytes received on host0",
  "options": {
    "no_data_timeframe": 20,
    "notify_audit": false,
    "notify_no_data": false,
    "silenced": {}
  },
  "org_id": 1499,
  "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
  "type": "metric alert",
  "multi": false,
  "created": "2015-12-18T16:34:14.014039+00:00",
  "modified": "2015-12-18T16:34:14.014039+00:00",
  "state": {
    "groups": {
      "host:host0": {
        "last_nodata_ts": null,
        "last_notified_ts": 1481909160,
        "last_resolved_ts": 1481908200,
        "last_triggered_ts": 1481909160,
        "name": "host:host0",
        "status": "Alert",
        "triggering_value": {
          "from_ts": 1481909037,
          "to_ts": 1481909097,
          "value": 1000
        }
      }
    }
  }
}

Modifier un monitor

ARGUMENTS:

  • query [obligatoire, facultatif lors de la modification] : La requête de la métrique pour laquelle les alertes sont envoyées.
  • name [obligatoire, facultatif lors de la modification] : Le nom du monitor.
  • message [facultatif, défaut=dynamique, en fonction de la requête] : Un message à inclure avec les notifications pour ce monitor. Les notifications par e-mail peuvent être envoyées à des utilisateurs spécifiques en utilisant la même notation « @nomutilisateur » que les événements.
  • options [facultatif, défaut={}] : Reportez-vous à la documentation relative à la création des monitors pour obtenir plus d’informations sur les options disponibles.
  • tags [facultatif, défaut=None] : La liste des tags à associer à votre monitor. Cela peut vous aider à catégoriser et à filtrer les monitors.

SIGNATURE:

PUT /v1/monitor/<ID_MONITOR>

EXEMPLE DE REQUÊTE:

from datadog import initialize,  api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Edit an existing monitor
api.Monitor.update(
    2081,
    query="avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
    name="Bytes received on host0",
    message="We may need to add web hosts if this is consistently high."
)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Edit an existing monitor
dog.update_monitor(91879, "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100", :message => "Bytes received on host0", :name => "We may need to add web hosts if this is consistently high.")
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
monitor_id=<YOUR_MONITOR_ID>

# Edit a monitor
curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high."
}' \
"https://api.datadoghq.com/api/v1/monitor/${monitor_id}"

EXEMPLE DE RÉPONSE:


{
    'id': 2081,
    'message': 'We may need to add web hosts if this is consistently high.',
    'name': 'Bytes received on host0',
    'options': {'notify_audit': False, 'notify_no_data': False, 'silenced': {}},
    'org_id': 2,
    'overall_state': 'No Data',
    'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
    'type': 'metric alert',
    'multi': False,
    'created': '2015-12-18T16:34:14.014039+00:00',
    'modified': '2015-12-18T18:39:24.391207+00:00'
}
[
    "200", {
        "name" => "We may need to add web hosts if this is consistently high.",
        "org_id" => 1499,
        "options" => {
            "notify_no_data" => false, "notify_audit" => false, "silenced" => {}
        },
        "state" => {},
        "query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
        "message" => "Bytes received on host0",
        "type" => "metric alert",
        "id" => 91879,
        "multi" => false,
        "created" => "2015-12-18T16:34:14.014039+00:00",
        "modified" => "2015-12-18T18:39:24.391207+00:00"
    }
]
{   "id": 91879,
  "message": "We may need to add web hosts if this is consistently high.",
  "name": "Bytes received on host0",
  "options": {
    "notify_audit": false,
    "notify_no_data": false,
    "silenced": {}
  },
  "org_id": 1499,
  "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
  "state": {},
  "type": "metric alert",
  "multi": false,
  "created": "2015-12-18T16:34:14.014039+00:00",
"modified": "2015-12-18T18:39:24.391207+00:00"}

Supprimer un monitor

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

DELETE /v1/monitor/<ID_MONITOR>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Delete a monitor
api.Monitor.delete(2081)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Delete a monitor
dog.delete_monitor(62625)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
monitor_id=<YOUR_MONITOR_ID>

# Delete a monitor
curl -X DELETE "https://api.datadoghq.com/api/v1/monitor/${monitor_id}?api_key=${api_key}&application_key=${app_key}"

EXEMPLE DE RÉPONSE:

{
    'deleted_monitor_id': 2081
}
["200", {
    "deleted_monitor_id" => 62625
}]
{
  "deleted_monitor_id": 59409
}

Récupérer tous les détails d’un monitor

ARGUMENTS:

  • group_states [facultatif, défaut=None] : Si cet argument est défini, les données renvoyées comprennent d’éventuelles informations supplémentaires concernant les états des groupes spécifiés, notamment le timestamp de la dernière notification, le timestamp de la dernière résolution et les détails du dernier déclenchement du monitor. L’argument doit inclure une liste de chaînes de caractères indiquant, le cas échéant, les états de groupe à inclure. Choisissez une ou plusieurs des valeurs suivantes : « all », « alert », « warn » ou « no data ». Par exemple : « alert,warn ».
  • name [facultatif, défaut=None] : Une chaîne de caractères permettant de filtrer les monitors en fonction de leur nom.
  • tags [facultatif, défaut=None] : Une liste séparée par des virgules indiquant les tags, le cas échéant, à utiliser afin de filtrer la liste des monitors par contexte (par ex., host:host0). Pour obtenir plus d’informations, consultez le paramètre tags pour l’argument query approprié dans la section Créer un monitor ci-dessus.
  • monitor_tags [facultatif, défaut=None] : Une liste séparée par des virgules indiquant le service ou les tags personnalisés, le cas échéant, à utiliser afin de filtrer la liste des monitors. Les tags créés dans l’interface utilisateur de Datadog ont automatiquement la clé de service ajoutée en préfixe (par ex., service:my-app)
  • with_downtimes [facultatif, défaut=true] : Si cet argument est défini sur true, alors les données renvoyées comprennent les downtimes de chaque monitor.
  • page [facultatif, défaut=0] : La page où la pagination démarre. Si cet argument n’est pas spécifié, la requête renvoie tous les monitors sans pagination.
  • page_size [facultatif, défaut=100] : Le nombre de monitors à renvoyer par page. Si l’argument page n’est pas spécifié, tous les monitors sont renvoyés par défaut sans limite page_size. En revanche, si page est spécifié et page_size ne l’est pas, l’argument prend par défaut la valeur 100.

SIGNATURE:

GET /v1/monitor

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Get all monitor details
print api.Monitor.get_all()
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Get all monitor details
dog.get_all_monitors()
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/monitor"

EXEMPLE DE RÉPONSE:

[
    {'creator': {
        'email': 'matt@example.com',
        'handle': 'matt@example.com',
        'id': 1896,
        'name': u'Matt'
    },
        'id': 2085,
        'message': u'',
        'name': '**system.net.bytes_rcvd** over **host:host0** was **> 100** on average during the **last 1h**.',
        'options': {'notify_audit': False, 'notify_no_data': False, 'silenced': {}},
        'org_id': 2,
        'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
        'type': 'metric alert',
        'multi': False,
        'created': '2015-12-18T16:34:14.014039+00:00',
        'modified': '2015-12-18T18:39:24.391207+00:00'},
    {'creator': {'email': 'matt@example.com',
                 'handle': 'matt@example.com',
                 'id': 1896,
                 'name': u'Matt'},
     'id': 2083,
     'message': 'We may need to add web hosts if this is consistently high.',
     'name': 'Bytes received on host0',
     'options': {'no_data_timeframe': 20,
                 'notify_audit': False,
                 'notify_no_data': True,
                 'silenced': {}},
     'org_id': 2,
     'overall_state': 'No Data',
     'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
     'type': 'metric alert',
     'multi': False,
     'created': '2015-12-18T16:34:14.014039+00:00',
     'modified': '2015-12-18T18:39:24.391207+00:00'
     }
]
[
    "200", [{
        "name" => "Bytes received on host0",
        "org_id" => 1499,
        "options" => {
            "notify_no_data" => false, "notify_audit" => false, "silenced" => {}
        },
        "query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
        "message" => "We may need to add web hosts if this is consistently high.",
        "type" => "metric alert",
        "multi" => false,
        "id" => 91879,
        "created" => "2015-12-18T16:34:14.014039+00:00",
        "modified" => "2015-12-18T16:34:14.014039+00:00"
    }, {
        "name" =>
        "**system.net.bytes_rcvd** over **host:host0** was **> 100** on average during the **last 1h**.",
        "org_id" => 1499,
        "options" => {
            "notify_audit" => true,
            "timeout_h" => nil,
            "silenced" => {},
            "no_data_timeframe" => false,
            "notify_no_data" => false,
            "renotify_interval" => nil,
            "escalation_message" => ""
        },
        "query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
        "message" => "",
        "type" => "metric alert",
        "multi" => false,
        "id" => 91875,
        "created" => "2015-12-18T16:34:14.014039+00:00",
        "modified" => "2015-12-18T16:34:14.014039+00:00"
    }]
]
[  
   {  
      "tags":[  

      ],
      "deleted":null,
      "query":"change(avg(last_5m),last_1m):avg:apache.net.hits{*} by {host} > 500",
      "message":"Host {{host.name}} with IP {{host.ip}} is under heavy load.",
      "matching_downtimes":[  

      ],
      "id":1111111,
      "multi":true,
      "name":"example title",
      "created":"2019-03-11T17:20:45.414125+00:00",
      "created_at":1552324845000,
      "creator":{  
         "id":1111111,
         "handle":"example@example.com",
         "name":"Jane Doe",
         "email":"example@example.com"
      },
      "org_id":1111111,
      "modified":"2019-03-11T17:20:45.414125+00:00",
      "overall_state_modified":"2019-03-19T12:55:48.320241+00:00",
      "overall_state":"No Data",
      "type":"query alert",
      "options":{  
         "notify_audit":false,
         "locked":false,
         "timeout_h":0,
         "silenced":{  

         },
         "include_tags":true,
         "no_data_timeframe":null,
         "require_full_window":true,
         "new_host_delay":300,
         "notify_no_data":false,
         "renotify_interval":0,
         "escalation_message":"",
         "thresholds":{  
            "critical":500,
            "warning":250
         }
      }
   },
   {  
      "tags":[  

      ],
      "deleted":null,
      "query":"avg(last_1m):outliers(avg:apache.net.hits{*} by {host}, 'DBSCAN', 3) > 0",
      "message":"@example@example.com",
      "matching_downtimes":[  

      ],
      "id":1111111,
      "multi":true,
      "name":"example title",
      "created":"2019-03-11T18:10:09.957865+00:00",
      "created_at":1552327809000,
      "creator":{  
         "id":111111,
         "handle":"example@example.com",
         "name":"Jane Doe",
         "email":"example@example.com"
      },
      "org_id":1111111,
      "modified":"2019-03-11T18:11:25.217705+00:00",
      "overall_state_modified":"2019-03-20T12:50:45.684420+00:00",
      "overall_state":"No Data",
      "type":"query alert",
      "options":{  
         "notify_audit":false,
         "locked":false,
         "timeout_h":0,
         "silenced":{  

         },
         "include_tags":true,
         "no_data_timeframe":null,
         "require_full_window":true,
         "new_host_delay":300,
         "notify_no_data":false,
         "renotify_interval":0,
         "escalation_message":""
      }
   }
]

Résoudre un monitor

ARGUMENTS:

  • resolve [obligatoire] : tableau de groupes à résoudre pour un monitor_id donné, p. ex. : {"monitor_id": "group_to_resolve"}

    Il est possible de spécifier plusieurs groupes par monitor, p. ex. : resolve: [{"monitor_id": "group_1"}, {"monitor_id": "group_2"}]

    Il est également possible de résoudre tous les groupes déclenchés à l’aide du pseudo-groupe ALL_GROUPS : resolve: [{"monitor_id": "ALL_GROUPS"}]

SIGNATURE:

POST https://api.datadoghq.com/monitor/bulk_resolve

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"resolve": [
          {"<YOUR_MONITOR_ID>": "<YOUR_FIRST_GROUP>"},
          {"<YOUR_MONITOR_ID>": "<YOUR_SECOND_GROUP>"}
      ]
}' \
"https://app.datadoghq.com/monitor/bulk_resolve"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
[
  {
    "tags": [
      "*"
    ],
    "deleted": null,
    "query": "avg(last_1h):avg:system.cpu.user{role:cassandra} by {host} > 10",
    "message": "I'm a dummy test.",
    "id": 2610751,
    "multi": true,
    "name": "[Do not mind] This is a test",
    "created": "2017-08-09T14:30:38.584147+00:00",
    "created_at": 1502289038000,
    "org_id": 11287,
    "modified": "2017-08-09T14:36:48.176919+00:00",
    "overall_state_modified": "2017-08-11T12:21:05.949182+00:00",
    "overall_state": "Alert",
    "type": "metric alert",
    "options": {
      "notify_audit": false,
      "locked": false,
      "timeout_h": 0,
      "silenced": {},
      "include_tags": false,
      "no_data_timeframe": 10,
      "new_host_delay": 300,
      "require_full_window": false,
      "notify_no_data": false,
      "renotify_interval": 0,
      "escalation_message": "",
      "thresholds": {
        "critical": 10,
        "warning": 5
      }
    }
  }
]

Désactiver tous les monitors

En désactivant tous les monitors, ceux-ci n’enverront plus de notifications par e-mail et n’enverront plus d’événements dans le flux d’événements. Vous devrez consulter la page d’alertes pour vérifier les changements d’état.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

POST /v1/monitor/mute_all

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Mute all monitors
api.Monitor.mute_all()
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Mute all alerts
dog.mute_monitors()
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/monitor/mute_all"

EXEMPLE DE RÉPONSE:


{
    'active': True,
    'disabled': False,
    'end': None,
    'id': 2728,
    'message': None,
    'scope': ['*'],
    'start': 1419440110
}
[
    "200", {
        "end" => nil,
        "disabled" => false,
        "start" => 1412805855,
        "active" => true,
        "scope" => ["*"],
        "id" => 1647
    }
]
{
  "active": true,
  "disabled": false,
  "end": null,
  "id": 1648,
  "scope": [
    "*"
  ],
  "start": 1412805856
}

Réactiver tous les monitors

Annule la désactivation de tous les monitors. Renvoie une erreur si la fonction de désactivation de tous les monitors n’a pas été utilisée auparavant.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

POST /v1/monitor/unmute_all

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Unmute all alerts
api.Monitor.unmute_all()
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Unmute all alerts
dog.unmute_monitors()
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/monitor/unmute_all"

EXEMPLE DE RÉPONSE:

Cet endpoint ne renvoie aucun objet JSON pour les requêtes réussies.

Désactiver un monitor

ARGUMENTS:

  • scope [facultatif, défaut=None] : Le contexte auquel appliquer la désactivation, p. ex. role:db. Par exemple, si votre alerte est groupée selon {host}, vous pouvez désactiver host:app1.
  • end [facultatif, défaut=None] : Timestamp POSIX correspondant à la fin de la désactivation.

SIGNATURE:

POST /v1/monitor/<ID_MONITOR>/mute

EXEMPLE DE REQUÊTE:


from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Mute a monitor
api.Monitor.mute(2088)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Mute a monitor
dog.mute_monitor(62628)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
monitor_id=<YOUR_MONITOR_ID>

# Mute a monitor
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/monitor/${monitor_id}/mute"

EXEMPLE DE RÉPONSE:



{
    'id': 2088,
    'message': 'We may need to add web hosts if this is consistently high.',
    'name': 'Bytes received on host0',
    'options': {
        'notify_audit': False,
        'notify_no_data': False,
        'silenced': {
            '*': None
        }
    },
    'org_id': 2,
    'overall_state': 'No Data',
    'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
    'type': 'metric alert',
    'created': '2015-12-18T16:34:14.014039+00:00',
    'modified': '2015-12-18T18:39:24.391207+00:00'
}
[
    "200", {
        "name" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
        "org_id" => 1499,
        "options" => {
            "notify_no_data" => false,
            "notify_audit" => true,
            "timeout_h" => nil,
            "silenced" => {
                "*" => nil
            },
            "is_data_sparse" => false,
            "renotify_interval" => nil
        },
        "state" => {},
        "query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
        "message" => "",
        "type" => "metric alert",
        "id" => 62628,
        "created" => "2015-12-18T16:34:14.014039+00:00",
        "modified" => "2015-12-18T18:39:24.391207+00:00"
    }
]
{
  "id": 62628,
  "message": "",
  "name": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
  "options": {
    "is_data_sparse": false,
    "notify_audit": true,
    "notify_no_data": false,
    "renotify_interval": null,
    "silenced": {
      "*": null
    },
    "timeout_h": null
  },
  "org_id": 1499,
  "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
  "state": {},
  "type": "metric alert",
  "created": "2015-12-18T16:34:14.014039+00:00",
  "modified": "2015-12-18T18:39:24.391207+00:00"
}

Réactiver un monitor

ARGUMENTS:

  • scope [facultatif, défaut=None] : Le contexte auquel appliquer la désactivation. Par exemple, si votre alerte est groupée par {host}, vous pouvez désactiver ‘host:app1’.
  • all_scopes [facultatif, défaut=False] : Supprime les désactivations pour tous les contextes.

SIGNATURE:

POST /v1/monitor/<ID_MONITOR>/unmute

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Unmute all alerts
api.Monitor.unmute(2088)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Unmute all alerts
dog.unmute_monitor(62628)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
monitor_id=<YOUR_MONITOR_ID>

# Unmute a monitor
curl -X POST \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/monitor/${monitor_id}/unmute"

EXEMPLE DE RÉPONSE:



{
    'id': 2088,
    'message': 'We may need to add web hosts if this is consistently high.',
    'name': 'Bytes received on host0',
    'options': {
        'notify_audit': False,
        'notify_no_data': False,
        'silenced': {}
    },
    'org_id': 2,
    'overall_state': 'No Data',
    'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
    'type': 'metric alert',
    'created': '2015-12-18T16:34:14.014039+00:00',
    'modified': '2015-12-18T18:39:24.391207+00:00'
}
[
    "200", {
        "name" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
        "org_id" => 1499,
        "options" => {
            "notify_no_data" => false,
            "notify_audit" => true,
            "timeout_h" => nil,
            "silenced" => {},
            "is_data_sparse" => false,
            "renotify_interval" => nil
        },
        "state" => {},
        "query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
        "message" => "",
        "type" => "metric alert",
        "id" => 62628,
        "created" => "2015-12-18T16:34:14.014039+00:00",
        "modified" => "2015-12-18T18:39:24.391207+00:00"
    }
]
{
  "id": 62628,
  "message": "",
  "name": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
  "options": {
    "is_data_sparse": false,
    "notify_audit": true,
    "notify_no_data": false,
    "renotify_interval": null,
    "silenced": {
      "*": null
    },
    "timeout_h": null
  },
  "org_id": 1499,
  "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
  "state": {},
  "type": "metric alert",
  "created": "2015-12-18T16:34:14.014039+00:00",
  "modified": "2015-12-18T18:39:24.391207+00:00"
}

Valider un monitor

Cet endpoint n’est pas pris en charge dans les bibliothèques client de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Valide la définition d’un monitor (consultez Créer un monitor pour découvrir comment élaborer une définition de monitor).

SIGNATURE:

POST /v1/monitor/validate

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "type": "metric alert",
      "query": "THIS QUERY IS INVALID",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high.",
      "tags": ["app:webserver", "frontend"],
      "options": {
      	"notify_no_data": true,
      	"no_data_timeframe": 20
      }
}' \
"https://api.datadoghq.com/api/v1/monitor/validate"

EXEMPLE DE RÉPONSE:

{}
["200", {}]
{
    "errors": [
        "The value provided for parameter 'query' is invalid"
    ]
}

Rechercher des monitors

Recherchez et filtrez les informations de vos monitors.

ARGUMENTS:

  • query [facultatif] :

    Après avoir saisi une requête de recherche dans votre page Manager Monitor, utilisez la valeur du paramètre de requête dans l’URL de la page comme valeur de ce paramètre. Consultez la page de documentation relative à la gestion des monitors pour en savoir plus.

    La requête peut contenir autant d’attributs de monitor que nécessaire (séparés par des espaces). Exemple : query="type:metric status:alert".

  • page [facultatif, défaut=0] :

    Page à partir de laquelle commencer la pagination.

  • per_page [facultatif, défaut=30] :

    Nombre de monitors à renvoyer par page.

  • sort [facultatif, défaut=null] :

    Une chaîne séparée par des virgules pour les champs pris en charge de l’ordre de tri (p. ex., name,asc) :

    • name
    • status
    • tags

SIGNATURE:

GET /v1/monitor/search

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
	'api_key': '<YOUR_API_KEY>',
	'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Search monitors
api.Monitor.search()

# Examples of possible query parameters:
# api.Monitor.search(query="id:7100311")
# api.Monitor.search(query="title:foo metric:system.core.idle status:Alert")
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Search monitors
dog.search_monitors()

# Examples of possible query parameters:
# dog.search_monitors(query="id:7100311")
# dog.search_monitors(query="title:foo metric:system.core.idle status:Alert")

#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

query=<MANAGE_MONITOR_QUERY>
page=<PAGE_NUMBER>
per_page=<PER_PAGE>
sort=<SORT>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/monitor/search?query=${query}&page=${page}&per_page=${per_page}&sort=${sort}"

EXEMPLE DE RÉPONSE:

{ u'counts': 
    { u'muted': [{ u'count': 1, u'name': False}],
      u'status': [{ u'count': 1, u'name': u'Alert'}],
      u'tag': [ { u'count': 1, u'name': u'env:myenv'},
                { u'count': 1, u'name': u'service:sample'}],
      u'type': [{ u'count': 1, u'name': u'apm'}]},
  u'metadata': { u'page': 0,
                 u'page_count': 1,
                 u'per_page': 30,
                 u'total_count': 1},
  u'monitors': 
    [ { u'classification': u'apm',
        u'creator': { u'handle': u'jane@example.com',
                      u'id': 795042,
                      u'name': u'Jane'},
        u'id': 6797333,
        u'last_triggered_ts': 1540483133,
        u'metrics': [ u'trace.servlet.request.hits',
                      u'trace.servlet.request.errors'],
        u'name': u'Service sample has a high error rate on env:myenv',
        u'notifications': [ { u'handle': u'jane@example.com',
                              u'name': u'Jane'}],
        u'org_id': 11287,
        u'scopes': [u'env:myenv', u'service:sample'],
        u'status': u'Alert',
        u'tags': [u'env:myenv', u'service:sample'],
        u'type': u'query alert'}]}
["200",
 {"counts"=>
   {"status"=>[{"count"=>1, "name"=>"Alert"}],
    "muted"=>[{"count"=>1, "name"=>false}],
    "tag"=>
     [{"count"=>1, "name"=>"env:myenv"},
      {"count"=>1, "name"=>"service:sample"}],
    "type"=>[{"count"=>1, "name"=>"apm"}]},
  "monitors"=>
   [{"status"=>"Alert",
     "scopes"=>["env:myenv", "service:sample"],
     "classification"=>"apm",
     "creator"=>
      {"handle"=>"jane@example.com",
       "id"=>795042,
       "name"=>"Jane"},
     "metrics"=>["trace.servlet.request.hits", "trace.servlet.request.errors"],
     "notifications"=>
      [{"handle"=>"jane@example.com", "name"=>"Jane"}],
     "last_triggered_ts"=>1540483133,
     "id"=>6797333,
     "name"=>"Service sample has a high error rate on env:myenv",
     "tags"=>["env:myenv", "service:sample"],
     "org_id"=>11287,
     "type"=>"query alert"}],
  "metadata"=>{"total_count"=>1, "page_count"=>1, "page"=>0, "per_page"=>30}}]
{
  "counts": {
    "status": [
      {
        "count": 4,
        "name": "No Data"
      },
      {
        "count": 2,
        "name": "OK"
      }
    ],
    "muted": [
      {
        "count": 3,
        "name": false
      },
      {
        "count": 3,
        "name": true
      }
    ],
    "tag": [
      {
        "count": 6,
        "name": "service:cassandra"
      }
    ],
    "type": [
      {
        "count": 6,
        "name": "metric"
      }
    ]
  },
  "monitors": [
    {
      "status": "No Data",
      "scopes": [
        "!availability-zone:us-east-1c",
        "name:cassandra"
      ],
      "classification": "metric",
      "creator": {
        "handle": "xxxx@datadoghq.com",
        "name": "xxxx@datadoghq.com",
        "id": {
          "handle": "xxxx@datadoghq.com",
          "id": 1234,
          "name": null
        }
      },
      "metrics": [
        "system.cpu.user"
      ],
      "notifications": [
        {
          "handle": "xxxx@datadoghq.com",
          "name": "xxxx@datadoghq.com"
        }
      ],
      "last_triggered_ts": null,
      "id": 2699850,
      "name": "Cassandra CPU is high on {{host.name}} in {{availability-zone.name}}",
      "tags": [
        "service:cassandra"
      ],
      "org_id": 1234,
      "type": "metric alert"
    },
    {
      "status": "OK",
      (...)
    },
  ],
  "metadata": {
    "total_count": 6,
    "page_count": 6,
    "page": 0,
    "per_page": 30
  }
}

Rechercher des groupes de monitors

Recherchez et filtrez les informations des groupes de vos monitors.

ARGUMENTS:

  • query [facultatif] :

    Après avoir saisi une requête de recherche dans votre page Manager Monitor, utilisez la valeur du paramètre de requête dans l’URL de la page comme valeur de ce paramètre. Consultez la page de documentation relative à la gestion des monitors pour en savoir plus.

  • page [facultatif, défaut=0] :

    Page à partir de laquelle commencer la pagination.

  • per_page [facultatif, défaut=30] :

    Nombre de monitors à renvoyer par page.

  • sort [facultatif, défaut=null] :

    Une chaîne séparée par des virgules pour les champs pris en charge de l’ordre de tri (par ex., name,asc) :

    • name
    • status
    • tags

SIGNATURE:

GET /v1/monitor/groups/search

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
	'api_key': '<YOUR_API_KEY>',
	'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Search monitor groups
api.Monitor.search_groups()
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Search monitor groups
dog.search_monitor_groups()
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

query=<MANAGE_MONITOR_QUERY>
page=<PAGE_NUMBER>
per_page=<PER_PAGE>
sort=<SORT>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/monitor/groups/search?query=${query}&page=${page}&per_page=${per_page}&sort=${sort}"

EXEMPLE DE RÉPONSE:

{ u'counts': 
  { u'status': [{ u'count': 1, u'name': u'Alert'}],
    u'type': [{ u'count': 1, u'name': u'apm'}]},
  u'groups': [ { u'group': u'*',
                 u'group_tags': [u'*'],
                 u'last_nodata_ts': 0,
                 u'last_triggered_ts': 1540483133,
                 u'monitor_id': 6797333,
                 u'monitor_name': u'Service sample has a high error rate on env:myenv',
                 u'status': u'Alert'}],
  u'metadata': { u'page': 0,
                 u'page_count': 1,
                 u'per_page': 30,
                 u'total_count': 1}}
["200",
 {"counts"=>
   {"status"=>[{"count"=>1, "name"=>"Alert"}],
    "type"=>[{"count"=>1, "name"=>"apm"}]},
  "groups"=>
   [{"status"=>"Alert",
     "last_triggered_ts"=>1540483133,
     "group"=>"*",
     "monitor_id"=>6797333,
     "group_tags"=>["*"],
     "last_nodata_ts"=>0,
     "monitor_name"=>"Service sample has a high error rate on env:myenv"}],
  "metadata"=>{"total_count"=>1, "page_count"=>1, "page"=>0, "per_page"=>30}}]
{
  "counts": {
    "status": [
      {
        "count": 2,
        "name": "OK"
      }
    ],
    "type": [
      {
        "count": 2,
        "name": "metric"
      }
    ]
  },
  "groups": [
    {
      "status": "OK",
      "last_triggered_ts": 1525702966,
      "group": "*",
      "monitor_id": 2738266,
      "group_tags": [
        "*"
      ],
      "last_nodata_ts": 0,
      "monitor_name": "[demo] Cassandra disk usage is high on {{host.name}}"
    },
    {
      "status": "OK",
      "last_triggered_ts": 1525703008,
      "group": "*",
      "monitor_id": 1576648,
      "group_tags": [
        "*"
      ],
      "last_nodata_ts": 0,
      "monitor_name": "[demo] Disk usage is high on {{host.name}}"
    }
  ],
  "metadata": {
    "total_count": 2,
    "page_count": 2,
    "page": 0,
    "per_page": 30
  }
}

Organisations

Les endpoints des organisations ne sont pas pris en charge dans les bibliothèques client de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Créez, modifiez et gérez vos organisations. En savoir plus sur les comptes multi-org.

Créer une organisation enfant

Cet endpoint requiert la fonctionnalité de compte multi-org et doit être activé en contactant l’assistance.

ARGUMENTS:

  • name [obligatoire] : Le nom de la nouvelle organisation enfant, limité à 32 caractères.
  • subscription [obligatoire] : Un tableau JSON contenant les types d’abonnement. Les types disponibles sont les suivants : trial, free et pro.
  • billing [obligatoire] : Un tableau JSON contenant les types de facturation. (seul le type parent_billing est pris en charge).

Une fois que vous avez créé une organisation enfant, vous pouvez interagir avec celle-ci en utilisant org.public_id, api_key.key et application_key.hash fournis dans la réponse.

SIGNATURE:

POST /v1/org

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "name" :"My Org",
        "subscription" :{"type":"pro"},
        "billing" :{"type":"parent_billing"}
}' \
"https://api.datadoghq.com/api/v1/org"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
  "org" : {
    "name" : "My Org",
    "public_id" : "axd2s",
    "subscription" : {
      "type" : "pro"
    },
    "billing" : {
      "type" : "parent_billing"
    }
  },
  "user" : {
    "name" : "Organization admin",
    "handle" : "test@datadoghq.com",
    ...
  },
  "api_key" : {
    "created_by": "user",
    "key": "6ccdfb88ff1aa63192c326"
    ...
  },
  "application_key": {
    "owner": "Organization admin",
    "hash": "88e5ae6a71f51d1d5a0071a24f",
    ...
  }
}

Récupérer une organisation

SIGNATURE:

GET /v1/org

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/org"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
  "orgs" : [{
      "name" : "My Org",
      "public_id" : "axd2s",
      "subscription" : {
        "type" : "pro"
      },
      "billing" : {
        "type" : "bill-parent"
    }
  }]
}

Mettre à jour une organisation

ARGUMENTS:

  • name [facultatif] : Le nom de l’organisation.
  • settings [facultatif] : Un tableau de paramètres JSON. Les paramètres possibles sont :
    • saml : définissez la propriété booléenne enabled afin d’activer ou de désactiver l’authentification unique par SAML. Consultez la documentation SAML pour en savoir plus sur l’ensemble des paramètres SAML.
    • saml_idp_initiated_login : possède une propriété enabled (booléenne).
    • saml_strict_mode : possède une propriété enabled (booléenne).
    • saml_autocreate_users_domains : possède deux propriétés, enabled (booléenne) et domains, qui correspond à la liste des domaines sans le symbole « @ ».

SIGNATURE:

PUT /v1/org/<ID_PUBLIQUE>

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
public_id=axd2s

curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
        "settings": {
            "saml": {
                "enabled": true
            },
            "saml_strict_mode": {
                "enabled": true
            },
            "saml_idp_initiated_login": {
                "enabled": true
            },
            "saml_autocreate_users_domains": {
                "enabled": true,
                "domains": [
                    "my-org.com",
                    "example.com"
                ]
            }
        }
}' \
"https://api.datadoghq.com/api/v1/org/${public_id}"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
  "org": {
    "public_id": "axd2s",
    "name": "My Org",
           "billing": {},
    "created": "2016-10-06 21:41:12",
    "settings": {
      "saml_can_be_enabled": true,
      "saml_idp_initiated_login": {
        "enabled": true
      },
      "saml": {
        "enabled": true
      },
      "saml_idp_endpoint": "https://idp.datadoghq.com/idp/profile/SAML2/POST/SSO",
      "saml_autocreate_users_domains": {
        "domains": [
          "my-org.com",
          "example.com"
        ],
        "enabled": true
      },
      "saml_login_url": "https://app.datadoghq.com/account/login/id/c81e728d9",
      "saml_idp_metadata_uploaded": true,
      "saml_strict_mode": {
        "enabled": true
      }
    },
    "subscription": {
      "type": "pro"
    }
  }
}

Importer les métadonnées IdP

Il existe plusieurs options permettant de mettre à jour les métadonnées de fournisseur d’identité (IdP) à partir de votre fournisseur d’identité SAML.

  • Multipart Form-Data : envoie le fichier de métadonnées IdP en publiant un formulaire.
  • XML Body : envoie le fichier de métadonnées IdP en tant que corps de la requête.

Multipart Form-Data

EN-TÊTES
  • Content-Type: multipart/form-data

ARGUMENTS:

  • idp_file [obligatoire] : le chemin vers le fichier de métadonnées XML que vous souhaitez importer.

XML Body

EN-TÊTES
  • Content-Type: application/xml

ARGUMENTS:

Le corps doit comprendre le contenu de votre fichier XML de métadonnées IdP.

SIGNATURE:

POST /v1/org/<ID_PUBLIQUE>/idp_metadata

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
public_id=<DD_APP_PUBLIC_ID>

# Upload IdP file using multipart/form-data
curl -X POST \
-H "Content-Type: multipart/form-data" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-F "idp_file=@metadata.xml" \
"https://api.datadoghq.com/api/v1/org/${public_id}/idp_metadata"

# OR

# Upload IdP file using application/xml
curl -X POST \
-H "Content-Type: application/xml" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
--data-binary "@metadata.xml" \
"https://api.datadoghq.com/api/v1/org/${public_id}/idp_metadata"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
  "message": "IdP metadata successfully uploaded for org Datadog HQ"
}

Screenboards

Cet endpoint est obsolète. Utilisez plutôt le nouvel endpoint Dashboards.
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Service Level Objectives

Service Level Objectives (or SLOs) are a key part of the site reliability engineering toolkit. SLOs provide a framework for defining clear targets around application performance, which ultimately help teams provide a consistent customer experience, balance feature development with platform stability, and improve communication with internal and external users.

For more information on creating SLOs, see the Configuring Service Level Objectives info.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Create a service level objective

Create a JSON to define your SLO.

ARGUMENTS:

  • type [required]: The type of the SLO, chosen from:
SLO Typesupported value
eventmetric
monitormonitor
  • name [required, default = dynamic, based on query]: The name of the SLO.
  • description [optional, default = empty]: A description of the SLO.
  • tags [optional, default = empty list]: A list of tags to associate with your SLO.
  • thresholds [required]: A list of Target thresholds, requires at least 1.

    • timeframe [required]: The timeframe to apply to the target value. Valid options are 7d, 30d, 90d.
    • target [required]: The target value to associate with the SLI that defines the SLO.
    • target_displauy [optional, default = dynamic, based on query]: The target display value that includes the requires level of precision.
    • warning [optional, default = none]: A warning target value to indicate when the SLI is close to breaching the target.
    • warning_display [optional, default = dynamic, based on query]: A warning target display value that includes the requires level of precision.

Monitor Based SLO

For more information, see Monitor SLOs.

  • monitor_ids [required, default = empty list]: Specify up to 20 monitor IDs directly for a monitor-based SLO. You can optionally on-create-dynamically select monitor IDs using the following option instead:
  • groups [optional, default = empty list]: Note: Only valid on single monitor SLOs Specify the selected groups as a sub query of the selected monitor.

Event Based SLOs

There is one type of event based SLO, a metric query. For more information, see Event SLOs.

Metric Query

  • query [required]: The query defines the metric-based SLO query. It requires two arguments:

    • numerator [required]: Defines the sum of the good events
    • denominator [required]: Defines the sum of the total events. Note: this should always be >= good events
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

POST /v1/slo

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

initialize(**options)

# Create a new SLO
thresholds = [
  {"timeframe": "7d", "target": 95},
  {"timeframe": "30d", "target": 95, "warning": 97},
]
tags = ["app:webserver", "frontend"]
api.ServiceLevelObjective.create(
    type="metric",
    name="Custom Metric SLO",
    description="SLO tracking custom service SLO",
    query={
        "numerator": "sum:my.custom.metric{type:good}.as_count()",
        "denominator": "sum:my.custom.metric{*}.as_count()"
    },
    tags=tags,
    thresholds=thresholds
)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'

dog = Dogapi::Client.new(api_key, app_key)

# Create a new SLO
thresholds = [
  {:timeframe => "7d", :target => 95},
  {:timeframe => "30d", :target => 95, :warning => 97},
]
tags = ['app:webserver', 'frontend']
dog.create_service_level_objective(
    :type => "metric",
    :name => "Custom Metric SLO",
    :description => "SLO tracking custom service SLO",
    :numerator => "sum:my.custom.metric{type:good}.as_count()",
    :denominator => "sum:my.custom.metric{*}.as_count()",
    :tags => tags,
    :thresholds => thresholds
)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST -H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "type": "monitor",
      "name": "Critical Foo Host Uptime",
      "description": "Track the uptime of host foo which is critical to the core business.",
      "tags": ["app:core", "kpi"],
      "monitor_ids": [42],
      "thresholds": [
        {"timeframe": "30d", "target": 95, "warning": 98}
      ]
}' \
"https://api.datadoghq.com/api/v1/slo"

EXAMPLE RESPONSE:

{
  "data": [
    {
      "id": "12341234123412341234123412341234",
      "description": "Track the uptime of host foo which is critical to the core business.",
      "name": "Critical Foo Host Uptime",
      "tags": ["app:core", "kpi"],
      "type": "monitor",
      "type_id": 0,
      "monitor_ids": [42],
      "thresholds": [
        {
          "timeframe": "30d",
          "target": 95,
          "warning": 98
        }
      ],
      "creator": {
        "handle": "foo",
        "email": "foo@foo.example.com",
        "id": 42,
      },
      "created": "2015-12-18T16:34:14.014039+00:00",
      "modified": "2015-12-18T16:34:14.014039+00:00"
    }
  ],
  "error": null
}
{
  "data": [
    {
      "id": "12341234123412341234123412341234",
      "description": "Track the uptime of host foo which is critical to the core business.",
      "name": "Critical Foo Host Uptime",
      "tags": ["app:core", "kpi"],
      "type": "monitor",
      "type_id": 0,
      "monitor_ids": [42],
      "thresholds": [
        {
          "timeframe": "30d",
          "target": 95,
          "warning": 98
        }
      ],
      "creator": {
        "handle": "foo",
        "email": "foo@foo.example.com",
        "id": 42,
      },
      "created": "2015-12-18T16:34:14.014039+00:00",
      "modified": "2015-12-18T16:34:14.014039+00:00"
    }
  ],
  "error": null
}
{
  "data": [
    {
      "id": "12341234123412341234123412341234",
      "description": "Track the uptime of host foo which is critical to the core business.",
      "name": "Critical Foo Host Uptime",
      "tags": ["app:core", "kpi"],
      "type": "monitor",
      "type_id": 0,
      "monitor_ids": [42],
      "thresholds": [
        {
          "timeframe": "30d",
          "target": 95,
          "warning": 98
        }
      ],
      "creator": {
        "handle": "foo",
        "email": "foo@foo.example.com",
        "id": 42,
      },
      "created": "2015-12-18T16:34:14.014039+00:00",
      "modified": "2015-12-18T16:34:14.014039+00:00"
    }
  ],
  "error": null
}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Get a service level objective’s details

Get a specific SLO’s details

ARGUMENTS:

This endpoint takes no JSON arguments.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

GET /v1/slo/<SLO_ID>

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

slo_id = '<YOUR_SLO_ID>'

initialize(**options)

api.ServiceLevelObjective.get(slo_id)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
slo_id  = '<YOUR_SLO_ID>'

dog = Dogapi::Client.new(api_key, app_key)

dog.get_service_level_objective(slo_id)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
slo_id=<YOUR_SLO_ID>

# Get a SLO
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/slo/${slo_id}"

EXAMPLE RESPONSE:

{
  "data": {
    "id": "12341234123412341234123412341234",
    "description": "Track the uptime of host foo which is critical to the core business.",
    "name": "Critical Foo Host Uptime",
    "tags": ["app:core", "kpi"],
    "type": "monitor",
    "type_id": 0,
    "monitor_ids": [42],
    "thresholds": [
      {
        "timeframe": "30d",
        "target": 95,
        "warning": 98
      }
    ],
    "creator": {
      "handle": "foo",
      "email": "foo@foo.example.com",
      "id": 42,
    },
    "created": "2015-12-18T16:34:14.014039+00:00",
    "modified": "2015-12-18T16:34:14.014039+00:00"
  },
  "error": null
}
{
  "data": {
    "id": "12341234123412341234123412341234",
    "description": "Track the uptime of host foo which is critical to the core business.",
    "name": "Critical Foo Host Uptime",
    "tags": ["app:core", "kpi"],
    "type": "monitor",
    "type_id": 0,
    "monitor_ids": [42],
    "thresholds": [
      {
        "timeframe": "30d",
        "target": 95,
        "warning": 98
      }
    ],
    "creator": {
      "handle": "foo",
      "email": "foo@foo.example.com",
      "id": 42,
    },
    "created": "2015-12-18T16:34:14.014039+00:00",
    "modified": "2015-12-18T16:34:14.014039+00:00"
  },
  "error": null
}
{
  "data": {
    "id": "12341234123412341234123412341234",
    "description": "Track the uptime of host foo which is critical to the core business.",
    "name": "Critical Foo Host Uptime",
    "tags": ["app:core", "kpi"],
    "type": "monitor",
    "type_id": 0,
    "monitor_ids": [42],
    "thresholds": [
      {
        "timeframe": "30d",
        "target": 95,
        "warning": 98
      }
    ],
    "creator": {
      "handle": "foo",
      "email": "foo@foo.example.com",
      "id": 42,
    },
    "created": "2015-12-18T16:34:14.014039+00:00",
    "modified": "2015-12-18T16:34:14.014039+00:00"
  },
  "error": null
}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Get a service level objective’s history

Get a specific SLO’s history, regardless of it’s SLO type.

The detailed history data is structured according to the source data type. For example, metric data is included for event SLOs that use the metric source, and monitor SLO types include the monitor transition history.

Note: There are different response formats for event based and time based SLO’s. Examples of both are shown.

ARGUMENTS:

This endpoint takes no JSON arguments.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

PUT /v1/slo/<SLO_ID>

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

slo_id = "<YOUR_SLO_ID>"

initialize(**options)

# Update an existing SLO (cannot change the 'type')

thresholds = [
  {"timeframe": "7d", "target": 95},
  {"timeframe": "30d", "target": 95, "warning": 97},
]
tags = ["app:webserver", "frontend"]
api.ServiceLevelObjective.update(
    id=slo_id,
    type="metric",
    name="Custom Metric SLO",
    description="SLO tracking custom service SLO",
    numerator="sum:my.custom.metric{type:good}.as_count()",
    denominator="sum:my.custom.metric{*}.as_count()",
    tags=tags,
    thresholds=thresholds
)
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
slo_id=<YOUR_SLO_ID>

# Edit a SLO
curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "name": "Host0 uptime",
      "description": "We may need to replace this host if it is constantly down."
}' \
"https://api.datadoghq.com/api/v1/slo/${slo_id}"

EXAMPLE RESPONSE:

{
  "data": [
    {
      "id": "12341234123412341234123412341234",
      "description": "Track the uptime of host foo which is critical to the core business.",
      "name": "Critical Foo Host Uptime",
      "tags": ["app:core", "kpi"],
      "type": "monitor",
      "type_id": 0,
      "monitor_ids": [42],
      "thresholds": [
        {
          "timeframe": "30d",
          "target": 95,
          "warning": 98
        }
      ],
      "creator": {
        "handle": "foo",
        "email": "foo@foo.example.com",
        "id": 42,
      },
      "created": "2015-12-18T16:34:14.014039+00:00",
      "modified": "2015-12-18T18:34:14.014039+00:00"
    }
  ],
  "error": null
}
{
  "data": [
    {
      "id": "12341234123412341234123412341234",
      "description": "Track the uptime of host foo which is critical to the core business.",
      "name": "Critical Foo Host Uptime",
      "tags": ["app:core", "kpi"],
      "type": "monitor",
      "type_id": 0,
      "monitor_ids": [42],
      "thresholds": [
        {
          "timeframe": "30d",
          "target": 95,
          "warning": 98
        }
      ],
      "creator": {
        "handle": "foo",
        "email": "foo@foo.example.com",
        "id": 42,
      },
      "created": "2015-12-18T16:34:14.014039+00:00",
      "modified": "2015-12-18T18:34:14.014039+00:00"
    }
  ],
  "error": null
}
{
  "data": [
    {
      "id": "12341234123412341234123412341234",
      "description": "Track the uptime of host foo which is critical to the core business.",
      "name": "Critical Foo Host Uptime",
      "tags": ["app:core", "kpi"],
      "type": "monitor",
      "type_id": 0,
      "monitor_ids": [42],
      "thresholds": [
        {
          "timeframe": "30d",
          "target": 95,
          "warning": 98
        }
      ],
      "creator": {
        "handle": "foo",
        "email": "foo@foo.example.com",
        "id": 42,
      },
      "created": "2015-12-18T16:34:14.014039+00:00",
      "modified": "2015-12-18T18:34:14.014039+00:00"
    }
  ],
  "error": null
}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Check if a service level objective can be deleted

Check if a SLO can be safely deleted.

ARGUMENTS:

This endpoint takes no JSON arguments.

Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

GET /v1/slo/<SLO_ID>/history?from_ts=<epoch timestamp>&to_ts=<epoch timestamp>

EXAMPLE REQUEST:

from datadog import initialize, api
import time

options = {
    'api_key': '<YOUR_API_KEY>',
    'app_key': '<YOUR_APP_KEY>'
}

slo_id = '<YOUR_SLO_ID>'

initialize(**options)

to_ts = int(time.time())
from_ts = to_ts - 60*60*24*30

api.ServiceLevelObjective.history(slo_id, from_ts=from_ts, to_ts=to_ts)
require 'rubygems'
require 'dogapi'

api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
slo_id  = '<YOUR_SLO_ID>'

dog = Dogapi::Client.new(api_key, app_key)

to_ts = 1571320613
from_ts = to_ts - 60*60*24*30

dog.get_service_level_objective_history(slo_id, from_ts, to_ts)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
slo_id=<YOUR_SLO_ID>
to_ts=<to epoch timestamp>
from_ts=<from epoch timestamp>

# Get SLO history
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/slo/${slo_id}/history?from_ts=${from_ts}&to_ts={$to_ts}"

EXAMPLE RESPONSE:

## Monitor Based
{
  "data": {
    "errors": null,
    "to_ts": 1571329541,
    "thresholds": {
      "90d": {
        "target": 98.0,
        "target_display": "98.000",
        "timeframe": "90d"
      }
    },
    "overall": {
      "uptime": 99.04629516601562,
      "span_precision": 2.0,
      "name": "We're not meeting our 1m SLAs for foo",
      "precision": {
        "90d": 3
      },
      "preview": true,
      "history": [
        [
          1564151047,
          0
        ],
        [
          1569231667,
          1
        ],
        [
          1569232747,
          0
        ],
        [
          1569310147,
          1
        ],
        [
          1569310447,
          0
        ],
        [
          1569345427,
          1
        ],
        [
          1569345487,
          0
        ],
        [
          1569355507,
          1
        ],
        [
          1569356347,
          0
        ],
        [
          1569504487,
          1
        ],
        [
          1569505027,