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 !

Présentation

Cette section décrit l’API HTTP de Datadog afin de transmettre des données vers et depuis Datadog.

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>'}

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

dog = Dogapi::Client.new('<YOUR_API_KEY>', '<YOUR_APP_KEY>')


curl "https://api.datadoghq.com/api/v1/validate?api_key=<YOUR_API_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 de 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 *[facultatif]* : L’entier du statut du check :

    • 0 : OK
    • 1 : WARNING
    • 2 : CRITICAL
    • 3 : UNKNOWN
  • timestamp *[faculatif]* : Timestamp POSIX de l’événement.

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

  • tags *[facultatif]* : La liste des tags key:val pour ce check.

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" \
-d '{
        "message" : "There is a problem with the database."
}' \
"https://api.datadoghq.com/api/v1/comments?api_key=${api_key}&application_key=${app_key}"
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" -d '{"message" : "This comment was submitted and will be edited by the api."}' "https://api.datadoghq.com/api/v1/comments?api_key=${api_key}&application_key=${app_key}" | jq -r '.comment.resource|ltrimstr("/api/v1/comments/")')

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

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"
  }
}
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.

Dashboards

This new endpoint unifies screenboard and timeboard APIs to allow you to manage all of your dashboards using a single format. Documentation for old endpoints is available here:

This endpoint allows you to programmatically create, update, delete, and query 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.

Create a Dashboard

Arguments
  • title [required]: Title of the dashboard.
  • widgets [required]: List of widgets to display on the dashboard. Widget definitions follow this form:
  • layout_type [required]: Layout type of the dashboard. Available values are: ordered (previous timeboard) or free (previous screenboard layout)
  • description [optional, default=None]: Description of the dashboard.
  • is_read_only [optional, default=False]: Whether this dashboard is read-only. If True, only the author and admins can make changes to it.
  • notify_list [optional, default=None]: List of handles of users to notify when changes are made to this dashboard.
  • template_variables [optional, default=None]: List of template variables for this dashboard. Template variable definitions follow this form:
    • name [required]: The name of the variable.
    • default [optional, default=None]: The default value for the template variable on dashboard load.
    • prefix [optional, default=None]: The tag prefix associated with the variable. Only tags with this prefix appear in the variable dropdown.
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" \
-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?api_key=${api_key}&application_key=${app_key}"
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"
}
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

Arguments
  • title [required]: Title of the dashboard.
  • widgets [required]: List of widgets to display on the dashboard. Widget definitions follow this form:
  • layout_type [required]: Layout type of the dashboard. Available values are: ordered (previous timeboard) or free (previous screenboard layout)
  • description [optional, default=None]: Description of the dashboard.
  • is_read_only [optional, default=False]: Whether this dashboard is read-only. If True, only the author and admins can make changes to it.
  • notify_list [optional, default=None]: List of handles of users to notify when changes are made to this dashboard.
  • template_variables [optional, default=None]: List of template variables for this dashboard. Template variable definitions follow this form:
    • name [required]: The name of the variable.
    • default [optional, default=None]: The default value for the template variable on dashboard load.
    • prefix [optional, default=None]: The tag prefix associated with the variable. Only tags with this prefix appear in the variable dropdown.
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" \
-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}?api_key=${api_key}&application_key=${app_key}"
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"
}
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

Delete an existing dashboard.

Arguments

This endpoint takes no JSON arguments.

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 "https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{
    'deleted_dashboard_id': 'qc9-tuk-9kv'
}
["200", {"deleted_dashboard_id" => "qc9-tuk-9kv"}]
{
    "deleted_dashboard_id": "qc9-tuk-9kv"
}
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 Dashboard

Fetch an existing dashboard’s definition.

Arguments

This endpoint takes no JSON arguments.

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 "https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}?api_key=${api_key}&application_key=${app_key}"
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"
}
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 Dashboards

Fetch all dashboards.

Arguments

This end point takes no JSON arguments.

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 "https://api.datadoghq.com/api/v1/dashboard?api_key=${api_key}&application_key=${app_key}"
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 \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}?api_key=${api_key}&application_key=${app_key}"
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 \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual?api_key=${api_key}&application_key=${app_key}"
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" \
-d '{
        "name": "My Dashboard List"
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual?api_key=${api_key}&application_key=${app_key}"
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" \
-d '{
        "name": "My Updated Dashboard List"
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}?api_key=${api_key}&application_key=${app_key}"

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 \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}?api_key=${api_key}&application_key=${app_key}"
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 \
"https://api.datadoghq.com/api/v2/dashboard/lists/manual/${list_id}/dashboards?api_key=${api_key}&application_key=${app_key}"
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': '/dash/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': '/screen/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" => "/dash/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" => "/screen/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": "/dash/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": "/screen/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.

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" \
-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?api_key=${api_key}&application_key=${app_key}"
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" \
-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?api_key=${api_key}&application_key=${app_key}"
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" \
-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?api_key=${api_key}&application_key=${app_key}"
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" \
-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?api_key=${api_key}&application_key=${app_key}"
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" \
-d "{
      \"scope\": \"env:prod\",
      \"start\": \"${currenttime}\"
  }" \
    "https://api.datadoghq.com/api/v1/downtime?api_key=${api_key}&application_key=${app_key}" | jq '.id')

curl -X PUT -H "Content-type: application/json" \
-d '{
      "scope": "env:staging",
      "message": "Doing some testing on staging"
}' \
    "https://api.datadoghq.com/api/v1/downtime/${downtime_id}?api_key=${api_key}&application_key=${app_key}"
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)

# Cancel downtime
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" \
-d "{
      \"scope\": \"env:prod\",
      \"start\": \"${currenttime}\"
  }" \
    "https://api.datadoghq.com/api/v1/downtime?api_key=${api_key}&application_key=${app_key}" | jq '.id')

curl -X DELETE -H "Content-type: application/json" "https://api.datadoghq.com/api/v1/downtime/${downtime_id}?api_key=${api_key}&application_key=${app_key}"
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" \
-d "{
      \"scope\": \"host:i-123\"
}" \
   "https://api.datadoghq.com/api/v1/downtime/cancel/by_scope?api_key=${api_key}&application_key=${app_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 
{
  "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)
# 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>

downtime_id=2473

curl "https://api.datadoghq.com/api/v1/downtime/${downtime_id}?api_key=${api_key}&application_key=${app_key}"
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
 }
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example 
{
  "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
print(dog.get_all_downtimes())
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -G "https://api.datadoghq.com/api/v1/downtime" \
     -d "api_key=${api_key}" \
     -d "application_key=${app_key}"

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 "https://api.datadoghq.com/api/v1/graph/embed?api_key=${api_key}&application_key=${app_key}"

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 -POST \
    -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?api_key=${api_key}&application_key=${app_key}"

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 "https://api.datadoghq.com/api/v1/graph/embed/${embed_id}?api_key=${api_key}&application_key=${app_key}"

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 "https://api.datadoghq.com/api/v1/graph/embed/${embed_id}/enable?api_key=${api_key}&application_key=${app_key}"

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 "https://api.datadoghq.com/api/v1/graph/embed/${embed_id}/revoke?api_key=${api_key}&application_key=${app_key}"

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
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 "https://api.datadoghq.com/api/v1/events/${event_id}?api_key=${api_key}&application_key=${app_key}"
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"
  }
}

Supprimer un événement

Cet endpoint vous permet de supprimer un événement.

ARGUMENTS

Cet endpoint ne prend aucun argument JSON.

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 -G -H "Content-type: application/json" \
    -d "start=${currenttime2}" \
    -d "end=${currenttime}" \
    -d "sources=My Apps" \
    -d "tags=-env:dev,application:web" \
    -d "unaggregated=true"\
    -d "api_key=<YOUR_API_KEY>" \
    -d "application_key=<YOUR_APP_KEY>" \
    "https://api.datadoghq.com/api/v1/events"
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"
    }
  ]
}

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.

Graphiques

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

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)

currenttime=$(date +%s)
currenttime2=$(date -v -1d +%s)

curl -G -H "Content-type: application/json" \
    -d "metric_query=system.load.1{*}" \
    -d "start=${currenttime2}" \
    -d "end=${currenttime}" \
    -d "api_key=<YOUR_API_KEY>" \
    -d "application_key=<YOUR_APP_KEY>" \
    "https://api.datadoghq.com/api/v1/graph/snapshot"

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"
}

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.

Hosts

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 -G "https://api.datadoghq.com/api/v1/hosts" \
     -d "api_key=${api_key}" \
     -d "application_key=${app_key}"
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": 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
}

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.
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 -G "https://api.datadoghq.com/api/v1/hosts/totals" \
     -d "api_key=${api_key}" \
     -d "application_key=${app_key}"
Exemple de réponse
{'total_up':1750,'total_active':1759}
["200", {"total_up":1750,"total_active":1759}]
{"total_up":1750,"total_active":1759}

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

Cet endpoint ne prend aucun argument JSON.

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" \
-d '{
      "message": "Muting this host for a test!"
}' "https://api.datadoghq.com/api/v1/host/test.host/mute?api_key=${api_key}&application_key=${app_key}"

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!"
}

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>/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" "https://api.datadoghq.com/api/v1/host/test.host/unmute?api_key=${api_key}&application_key=${app_key}"

Exemple de réponse
{
    'action': 'Unmuted',
    'hostname': 'test.host'
}
["200", {
    "action" => "Unmuted",
    "hostname" => "test.host"
}]
{
  "action": "Unmuted",
  "hostname": "test.host"
}

Réactiver un host

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.

Integration AWS

The AWS endpoints are not supported in Datadog’s client libraries. To request this functionality, contact Datadog Support.

Configure your Datadog-AWS integration directly through Datadog API. For more information, see the AWS integration page.

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
# 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 AWS Accounts (role-based only) in Datadog
curl -X GET "https://api.datadoghq.com/api/v1/integration/aws?api_key=${api_key}&application_key=${app_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
{"accounts":
    [{
        "account_id": '112233445566',
        "role_name": "SomeDatadogRole",
        "filter_tags": ["filter123"],
        "host_tags": ["account":"demo"],
        "account_specific_namespace_rules": {"opsworks":false}
    }]
}
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.

List all AWS integrations

List all Datadog-AWS integrations available in your Datadog organization.

Arguments

This endpoint takes no JSON arguments.

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
# 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>

# Create an AWS Account in Datadog
curl -X POST -H "Content-type: application/json" \
-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?api_key=${api_key}&application_key=${app_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
{
    "external_id": "12345678910111213"
}
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 an AWS integration

Create a Datadog-Amazon Web Services integration.

Note: Using the POST method updates your integration configuration by adding your new configuration to the existing one in your Datadog organization.

ARGUMENTS
  • account_id [required]:

    Your AWS Account ID without dashes. Consult the Datadog AWS integration to learn more about your AWS account ID.

  • access_key_id [optional, default=None]:

    If your AWS account is a GovCloud or China account, enter the corresponding Access Key ID.

  • role_name [required]:

    Your Datadog role delegation name. For more information about you AWS account Role name, see the Datadog AWS integration configuration info.

  • filter_tags [optional, default=None]:

    The array of EC2 tags (in the form key:value) defines a filter that Datadog uses when collecting metrics from EC2. Wildcards, such as ? (for single characters) and * (for multiple characters) can also be used. Only hosts that match one of the defined tags will be imported into Datadog. The rest will be ignored. Host matching a given tag can also be excluded by adding ! before the tag. e.x. env:production,instance-type:c1.*,!region:us-east-1 For more information on EC2 tagging, see the AWS tagging documentation.

  • host_tags [optional, default=None]:

    Array of tags (in the form key:value) to add to all hosts and metrics reporting through this integration.

  • account_specific_namespace_rules [optional, default=None]:

    An object (in the form {"namespace1":true/false, "namespace2":true/false}) that enables or disables metric collection for specific AWS namespaces for this AWS account only. A list of namespaces can be found at the /v1/integration/aws/available_namespace_rules endpoint.

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 \
  "https://api.datadoghq.com/api/v1/integration/aws?api_key=${api_key}&application_key=${app_key}&account_id=<YOUR_AWS_ACCOUNT_ID>&role_name=<ROLE_NAME>" \
  -H 'Content-Type: application/json' \
  -d '{
    "filter_tags": [
        "<TAG_KEY>:<TAG_VALUE>"
    ],
    "host_tags": [
        "<TAG_KEY>:<TAG_VALUE>"
    ],
    "account_specific_namespace_rules": {
        "auto_scaling": false,
        "opsworks": false
    }
}'
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.

Update an AWS integration

Update a Datadog-Amazon Web Services integration.

Note: Using the PUT method updates your integration configuration by replacing your current configuration with the new one sent to your Datadog organization.

ARGUMENTS
  • account_id [required]:

    Your AWS Account ID without dashes. It needs to be passed as query parameter. Consult the Datadog AWS integration to learn more about your AWS account ID.

  • role_name [required]:

    Your Datadog role delegation name. It needs to be passed as query parameter. For more information about your AWS account Role name, see the Datadog AWS integration configuration info.

  • access_key_id [optional, default=None]:

    If your AWS account is a GovCloud or China account, enter the corresponding Access Key ID.

  • filter_tags [optional, default=None]:

    The array of EC2 tags (in the form key:value) defines a filter that Datadog uses when collecting metrics from EC2. Wildcards, such as ? (for single characters) and * (for multiple characters) can also be used. Only hosts that match one of the defined tags are imported into Datadog. The rest are ignored. Host matching a given tag can also be excluded by adding ! before the tag. e.x. env:production,instance-type:c1.*,!region:us-east-1 For more information on EC2 tagging, see the AWS tagging documentation.

  • host_tags [optional, default=None]:

    Array of tags (in the form key:value) to add to all hosts and metrics reporting through this integration.

  • account_specific_namespace_rules [optional, default=None]:

    An object (in the form {"namespace1":true/false, "namespace2":true/false}) that enables or disables metric collection for specific AWS namespaces for this AWS account only. A list of namespaces can be found at the /v1/integration/aws/available_namespace_rules endpoint.

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" \
-d '{
        "account_id": "<AWS_ACCOUNT_ID>",
        "role_name": "DatadogAWSIntegrationRole"
}' \
"https://api.datadoghq.com/api/v1/integration/aws?api_key=${api_key}&application_key=${app_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
{}
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 an AWS integration

Delete a given Datadog-AWS integration.

Arguments
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 "https://api.datadoghq.com/api/v1/integration/aws/available_namespace_rules?api_key=${api_key}&application_key=${app_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_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"]
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.

List Namespace rules

List all namespace rules for a given Datadog-AWS integration.

Arguments

This endpoint takes no JSON 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"
-d
  '{
    "account_id": "<YOUR_AWS_ACCOUNT_ID>",
    "role_name": "DatadogAWSIntegrationRole"
    }'

"https://dd.datadoghq.com/api/v1/integration/aws/generate_new_external_id?${api_key}&application_key=${app_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
{}
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.

Generate External IDs

Generate a new AWS external id for a given AWS account id and role name pair.

Arguments
Signature

GET /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 "https://api.datadoghq.com/api/v1/integration/aws/logs/services?api_key=${api_key}&application_key=${app_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
{}
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

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" \
-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?api_key=${api_key}&application_key=${app_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
{}
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 AWS log lambda ARN

Attach the Lambda ARN of the Lambda created for the Datadog-AWS log collection to your AWS account ID to enable log collection.

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 "Content-type: application/json" \
-d '{
        "account_id": "<AWS_ACCOUNT_ID>",
        "services": ["elb","s3"]
    }'\
"https://api.datadoghq.com/api/v1/integration/aws/logs/services?api_key=${api_key}&application_key=${app_key}"
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.

Enable an AWS service log collection

Enable Automatic Log collection for your AWS services.

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" \
-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?api_key=${api_key}&application_key=${app_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
{}
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
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.

Integration Azure

The Azure endpoints are not supported in Datadog’s client libraries. To request this functionality, contact Datadog Support.

Configure your Datadog-Azure integration directly through the Datadog API. For more information, see the Datadog-Azure integration page.

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
# 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 "https://api.datadoghq.com/api/v1/integration/azure?api_key=${api_key}&application_key=${app_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
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.

List all Azure integrations

List all Datadog-Azure integrations configured for your organization.

Arguments

This endpoint takes no JSON arguments.

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
# 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>

# Create an Azure account in Datadog
curl -X POST -H "Content-type: application/json" \
-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?api_key=${api_key}&application_key=${app_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
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.

Create an Azure integration

Create a Datadog-Azure integration.

Note:

  • Using the POST method updates your integration configuration by adding your new configuration to the existing one in your Datadog organization.
  • Using the PUT method updates your integration configuration by replacing your current configuration with the new one sent to your Datadog organization.
ARGUMENTS

Refer to the Datadog-Azure integration installation instructions to see how to obtain the following field values for your organization.

  • tenant_name [required]:

    Your Azure Active Directory ID.

  • client_id [required]:

    Your Azure web application ID.

  • client_secret [required]:

    Your Azure web application secret key.

  • host_filters [optional, default=None]:

    Limit the Azure instances that are pulled into Datadog by using tags. Only hosts that match one of the defined tags are imported into 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>

# Create an Azure account in Datadog
curl -X POST -H "Content-type: application/json" \
-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?api_key=${api_key}&application_key=${app_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
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.

Delete an Azure integration

Delete a given Datadog-Azure integration.

Arguments

Refer to the Datadog-Azure integration installation instructions to see how to obtain the following field values for your organization.

  • tenant_name [required]:

    Your Azure Active Directory ID.

  • client_id [required]:

    Your Azure web application ID.

  • host_filters [optional, default=None]:

    Limit the Azure instances that are pulled into Datadog by using tags. Only hosts that match one of the defined tags are imported into 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
# 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>

# Create an Azure account in Datadog
curl -X POST -H "Content-type: application/json" \
-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?api_key=${api_key}&application_key=${app_key}"
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
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.

Update an Azure integration host filters

Update the defined list of host filters for a given Datadog-Azure integration.

ARGUMENTS

Refer to the Datadog-Azure integration installation instructions to see how to obtain the following field values for your organization.

  • tenant_name [required]:

    Your Azure Active Directory ID.

  • client_id [required]:

    Your Azure web application ID.

  • client_secret [required]:

    Your Azure web application secret key.

  • host_filters [optional, default=None]:

    Limit the Azure instances that are pulled into Datadog by using tags. Only hosts that match one of the defined tags are imported into Datadog.

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.

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
# 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 "https://api.datadoghq.com/api/v1/integration/gcp?api_key=${api_key}&application_key=${app_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
OK

É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

POST /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 POST -H "Content-type: application/json" \
-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?api_key=${api_key}&application_key=${app_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
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

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" \
-d '{
        "project_id": "<GCP_PROJECT_ID>",
        "client_email": "<CLIENT_EMAIL>"
    }' \
"https://api.datadoghq.com/api/v1/integration/gcp?api_key=${api_key}&application_key=${app_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
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

PUT /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 PUT -H "Content-type: application/json" \
-d '{
        "project_id": "<GCP_PROJECT_ID>",
        "client_email": "<CLIENT_EMAIL>",
        "automute": <AUTOMUTE> # true or false
    }' \
"https://api.datadoghq.com/api/v1/integration/gcp?api_key=${api_key}&application_key=${app_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
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.

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.

Integration PagerDuty

The PagerDuty endpoints are not supported in Datadog’s client libraries. To request this functionality, contact Datadog Support.

Configure your Datadog-PagerDuty integration directly through the Datadog API. For more informations, see the PagerDuty integration page.

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
# 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 -v -X GET \
"https://api.datadoghq.com/api/v1/integration/pagerduty?api_key=${api_key}&application_key=${app_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
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.

Get a PagerDuty integration

Get all information about your Datadog-PagerDuty integration.

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/integration/pagerduty

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 -v -X PUT -H "Content-type: application/json" \
-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?api_key=${api_key}&application_key=${app_key}"
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
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

POST /v1/integration/pagerduty

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 -v -X POST -H "Content-type: application/json" \
-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?api_key=${api_key}&application_key=${app_key}"
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
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 new services and schedules

Add new services and schedules to your Datadog-PagerDuty integration.

Arguments
  • services : The array of PagerDuty service objects. Learn how to configure your Datadog service with the PagerDuty documentation. A PagerDuty service object is composed by:

    • service_name [required]: Your Service name in PagerDuty.

    • service_key [required]: Your Service name associated service key in Pagerduty.

  • schedules : The array of your schedule URLs: ["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

DELETE /v1/integration/pagerduty

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 -v -X DELETE \
"https://api.datadoghq.com/api/v1/integration/pagerduty?api_key=${api_key}&application_key=${app_key}"
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
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.

Delete a PagerDuty integration

Delete the Datadog-PagerDuty integration.

Arguments

This endpoint takes no JSON arguments.

Intégration Slack

Les endpoints Slack 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/Slack directement avec l’API Datadog.
Pour en savoir plus sur l’intégration Datadog/Slack, consultez la page d’intégration.

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
# 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 -v -X GET "https://api.datadoghq.com/api/v1/integration/slack?api_key=${api_key}&application_key=${app_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
OK

Obtenir l’intégration Slack

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

Arguments

Cet endpoint ne prend aucun argument JSON.

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
# 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 -v -X POST -H "Content-type: application/json" \
-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?api_key=${api_key}&application_key=${app_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
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
# 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" \
-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?api_key=${api_key}&application_key=${app_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
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

DELETE /v1/integration/slack

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 -v -X DELETE "https://api.datadoghq.com/api/v1/integration/slack?api_key=${api_key}&application_key=${app_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
OK

Supprimer une intégration Slack

Supprimez une intégration Datadog/Slack.

Arguments

Cet endpoint ne prend aucun argument JSON.

Intégration Webhooks

Les endpoints des Webhooks 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/Webhooks directement avec l’API Datadog. Pour en savoir plus sur l’intégration Datadog/Webhooks, consultez la page d’intégration.

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
# 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 -v -X GET "https://api.datadoghq.com/api/v1/integration/webhooks?api_key=${api_key}&application_key=${app_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
OK

Obtenir une intégration Webhooks

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

Arguments

Cet endpoint ne prend aucun argument JSON.

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
# 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 -v -X POST -H "Content-type: application/json" \
-d '{
    "hooks": [
      {
        "name": "<WEBHOOK_NAME>",
        "url": "<WEBHOOK_URL>",
        "use_custom_payload": "false",
        "encode_as_form": "false"
      }
    ]
}' \
"https://api.datadoghq.com/api/v1/integration/webhooks?api_key=${api_key}&application_key=${app_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
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 sur true pour chiffrer l’URL de votre charge utile.

    • headers [facultatif, défaut=None] : En-têtes attaché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
# 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 -v -X POST -H "Content-type: application/json" \
-d '{
    "hooks": [
      {
        "name": "<WEBHOOK_NAME>",
        "url": "<WEBHOOK_URL>"
      }
    ]
}' \
"https://api.datadoghq.com/api/v1/integration/webhooks?api_key=${api_key}&application_key=${app_key}"
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
OK

Ajouter un Webhook à 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 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 sur true pour chiffrer l’URL de votre charge utile.

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

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
# 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 -v -X DELETE "https://api.datadoghq.com/api/v1/integration/webhooks?api_key=${api_key}&application_key=${app_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
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.

Delete a Webhooks Integration

Delete a given Datadog-Webhooks integration.

Arguments

This endpoint takes no JSON arguments.

Signature

GET https://api.datadoghq.com/api/v1/screen

Exemple de requête
from datadog import initialize, api

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

initialize(**options)

api.Screenboard.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_screenboards()
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X GET "https://api.datadoghq.com/api/v1/screen?api_key=${api_key}&application_key=${app_key}"

Exemple de réponse
{
    'screenboards': [
        {
            'description': 'This has all the new hotness.',
            'id': '2551',
            'resource': '/api/v1/screen/2551',
            'title': 'New and Improved Screenboard',
            'created': '2015-12-17T21:29:40.890824+00:00',
            'modified': '2015-12-17T21:39:20.770834+00:00',
            'read_only': False
        },
        {
            'description': 'And they are marvelous.',
            'id': '2552',
            'resource': '/api/v1/screen/2552',
            'title': 'My First Metrics',
            'created': '2015-12-17T21:29:40.890824+00:00',
            'modified': '2015-12-17T21:39:20.770834+00:00',
            'read_only': False
        }
    ]
}
[
    "200", {
        "screenboards" => [{
            "created" => "2015-12-17T20:00:25.050990+00:00",
            "resource" => "/api/v1/screen/6334",
            "id" => 6334,
            "modified" => "2015-12-17T20:00:25.051176+00:00",
            "title" => "dogapi test",
            "read_only" => false
        }, {
            "created" => "2015-12-17T20:00:25.868731+00:00",
            "resource" => "/api/v1/screen/2",
            "id" => 2,
            "modified" => "2015-12-17T20:00:25.868752+00:00",
            "title" => "Database Screenboard",
            "read_only" => false
        }]
    }
]

[
  {
    'description': 'This has all the new hotness.',
    'id': '2551',
    'resource': '/api/v1/screen/2551',
    'title': 'New and Improved Screenboard',
    'created': '2015-12-17T23:06:06.703087+00:00',
    'modified': '2015-12-17T23:12:26.726234+00:00',
    'read_only': 'false'
  },
  {
    'description': 'And they are marvelous.',
    'id': '2552',
    'resource': '/api/v1/screen/2552',
    'title': 'My First Metrics',
    'created': '2015-12-17T23:06:06.703087+00:00',
    'modified': '2015-12-17T23:12:26.726234+00:00',
    'read_only': 'false'
  }
]

Récupérer un screenboard

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

ARGUMENTS

Cet endpoint ne prend aucun argument JSON.

Récupérer tous les screenboards

Récupérez toutes les définitions de vos screenboards.

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 \
  "https://app.datadoghq.com/api/v1/api_key?api_key=${api_key}}&application_key=${app_key}" \
  -H 'Content-Type: application/json'
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"
        }
    ]
}

Partager un screenboard

Partage un screenboard existant avec une URL publique.

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 \
  "https://app.datadoghq.com/api/v1/api_key/<API_KEY_TO_GET>?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json'
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"
    }
}
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.

Key Management

The Key Management endpoints are not supported in Datadog’s client libraries. To request this functionality, contact Datadog Support.

Manage your Datadog API and application keys.

You need an API and applications key with Admin rights to interact with this endpoint.

The full list of keys can be seen on your Datadog API page.

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 \
  "https://app.datadoghq.com/api/v1/api_key?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json' \
  -d '{
	"name": "<API_KEY_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
{
    "api_key": {
        "created_by": "john@example.com",
        "name": "<API_KEY_NAME>",
        "key": "3111111111111111aaaaaaaaaaaaaaaa",
        "created": "2019-04-05 09:47:00"
    }
}
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 API Keys

Get all API keys available for your account.

ARGUMENTS

This endpoint takes no JSON arguments.

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 \
  "https://app.datadoghq.com/api/v1/api_key/<API_KEY_TO_EDIT>?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json' \
  -d '{
    "name":"<NEW_API_KEY_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
{
    "api_key": {
        "created_by": "john@example.com",
        "name": "<API_KEY_NAME>",
        "key": "3111111111111111aaaaaaaaaaaaaaaa",
        "created": "2019-04-05 09:47:00"
    }
}
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 an API Key

Get a given API key.

ARGUMENTS

This endpoint takes no JSON arguments.

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 \
  "https://app.datadoghq.com/api/v1/api_key/<API_KEY_TO_DELETE>?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json'
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"
    }
}
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 an API Key

Create an API key with a given name.

ARGUMENTS
  • name [required]:

    Name of your API key.

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 \
  "https://app.datadoghq.com/api/v1/application_key?api_key=${api_key}}&application_key=${app_key}" \
  -H 'Content-Type: application/json'
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>"
        }
    ]
}
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.

Edit an API Key

Edit an API key name.

ARGUMENTS
  • name [required]:

    Name of your API key.

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 \
  "https://app.datadoghq.com/api/v1/application_key/<APP_KEY_TO_GET>?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json'
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>"
    }
}
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 an API Key

Delete a given API key.

ARGUMENTS

This endpoint takes no JSON arguments.

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 \
  "https://app.datadoghq.com/api/v1/application_key?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json' \
  -d '{
	"name": "<APP_KEY_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
{
    "application_key": {
        "owner": "john@example.com",
        "hash": "31111111111111111111aaaaaaaaaaaaaaaaaaaa",
        "name": "<APP_KEY_NAME>"
    }
}
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 Application Keys

Get all application keys available for your account.

ARGUMENTS

This endpoint takes no JSON arguments.

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 \
  "https://app.datadoghq.com/api/v1/application_key/<APP_KEY_TO_EDIT>?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json' \
  -d '{
    "name":"<NEW_APP_KEY_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
{
    "application_key": {
        "owner": "john@example.com",
        "hash": "31111111111111111111aaaaaaaaaaaaaaaaaaaa",
        "name": "<NEW_APP_KEY_NAME>"
    }
}
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 an Application Key

Get a given application key.

ARGUMENTS

This endpoint takes no JSON arguments.

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 \
  "https://app.datadoghq.com/api/v1/application_key/<APP_KEY_TO_DELETE>?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json'
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>"
    }
}
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 an Application Key

Create an application key with a given name.

ARGUMENTS
  • name [required]:

    Name of your application key.

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.

Edit an application Key

Edit an application key name.

ARGUMENTS
  • name [required]:

    Name of your application key.

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
{}
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 an Application Key

Delete a given application key.

ARGUMENTS

This endpoint takes no JSON arguments.

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 \
  "https://api.datadoghq.com/api/v1/logs-queries/list?api_key=${api_key}&application_key=${app_key}" \
  -H 'content-type: application/json' \
  -d '{"query": "service:nginx -@http.method:POST","time": {"from": "now - 1h", "to": "now"}, "sort": "desc", "limit": 50}'
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"
}

Logs

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

  • Taille maximale du contenu par charge utile : 2 Mo
  • Taille maximale d’un log : 256 Ko
  • Taille maximale d’un tableau en cas d’envoi de plusieurs logs dans un tableau : 50 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

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 \
  "https://api.datadoghq.com/api/v1/logs/config/indexes?api_key=${api_key}&application_key=${app_key}" \
  -H 'content-type: application/json'
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
                }
            }
        ]
    }
  ]
}

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.

ARGUMENTS
  • query [obligatoire] : la requête de recherche ; elle respecte 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] : 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.
PAGINATION

Récupérez une liste de logs contenant plus de 1 000 logs (soit la limite) avec la fonctionnalité Pagination de l’API Log List :

  • pour la première requête, utilisez le paramètre startAt.
  • pour la requête N, utilisez le nextLogId du résultat N - 1 de la requête en tant que valeur du paramètre startAt.

Pour contrôler davantage les résultats de la pagination, vous devez utiliser un paramètre time absolu. N’utilisez pas le mot-clé now.

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.

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 \
  "https://api.datadoghq.com/api/v1/logs/config/indexes/<INDEX_NAME>?api_key=${api_key}&application_key=${app_key}" \
  -H 'content-type: application/json'
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
			}
		}
	]
}
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.

Logs Indexes

This endpoint is in public beta and not supported in Datadog's client libraries. If you have any feedback, contact Datadog support.

The Index object describes the configuration of a log index. It has the following attributes:

  • name (Read Only): The name of the index.
  • filter.query : Only logs matching the filter criteria are considered for this index. The search query followis the Log search syntax
  • num_retention_days (Read Only) : The number of days before logs are deleted from this index
  • daily_limit (Read Only) : The number of log-events you can send in this index before you are rate-limited.
  • is_rate_limited (Read Only) : A boolean stating if the index is rate limited, meaning more logs than the daily limit have been sent. Rate limit is reset every-day at 2pm UTC.
  • exclusion_filters An array of ExclusionFilter objects (see hereafter). The logs are tested against the query of each ExclusionFilter, following the order of the array. Only the first matching active ExclusionFilter matters, others (if any) are ignored.

    • name : The name of the exclusion filter
    • is_enabled : A boolean stating if the exclusion is active (will eventually exclude logs) or not.
    • filter.query : Only logs matching the filter criteria AND the query of the parent index will be considered for this exclusion filter. The search query follows the Log search syntax
    • filter.sample_rate : The fraction of logs excluded by the exclusion filter, when active. The sampling is uniform.

Note: You need an API and applications key with Admin right to interact with this endpoint.

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 \
  "https://api.datadoghq.com/api/v1/logs/config/indexes/<INDEX_NAME>?api_key=${api_key}&application_key=${app_key}" \
  -H 'content-type: application/json' \
  -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
        }
      }
    ]
}'
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
        }
      }
	]
}
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 Indexes

This endpoint is in public beta. If you have any feedback, contact Datadog support.

This endpoint returns an array of the Index objects of your organization.

Arguments

This endpoint takes no JSON arguments.

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 \
  "https://api.datadoghq.com/api/v1/logs/config/index-order?api_key=${api_key}&application_key=${app_key}" \
  -H 'content-type: application/json'
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>"
	]
}
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 an Index

This endpoint is in public beta. If you have any feedback, contact Datadog support.

This endpoint returns an Index identified by its name.

Arguments

This endpoint takes no JSON arguments.

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 \
  "https://api.datadoghq.com/api/v1/logs/config/index-order?api_key=${api_key}&application_key=${app_key}" \
  -H 'content-type: application/json' \
  -d '{
	"index_names": [
    "<INDEX_NAME_2>",
		"<INDEX_NAME_1>"
	]
}'
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>"
	]
}
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 an Index

This endpoint is in public beta. If you have any feedback, contact Datadog support.

This endpoint updates an Index identified by its name. It returns the Index object passed in the request body when the request is successful.

Arguments
  • filter.query [optional]: Only logs matching the filter criteria will be considered for this index. The search query followis the Log search syntax
  • exclusion_filters An array of ExclusionFilter objects (see hereafter). The logs are tested against the query of each ExclusionFilter, following the order of the array. Only the first matching active ExclusionFilter matters, others (if any) are ignored. The ExclusionFilter object describes the configuration of an exclusion filter. It has the following attributes:

    • name [required]: The name of the exclusion filter
    • is_enabled [optional, default=False]: A boolean stating if the exclusion is active.
    • filter.query [optional]: Only logs matching the filter criteria AND the query of the parent index will be considered for this exclusion filter. The search query follows the Log search syntax
    • filter.sample_rate [required]: The fraction of logs excluded by the exclusion filter, when active. The sampling is uniform.
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 Indexes Order

This endpoint is in public beta. If you have any feedback, contact Datadog support.

Use the index order endpoints to control the processing order of an organization’s indexes. Use this endpoint only if you have more than one index for logs in your organization. Note that this index cannot be used to add or delete indexes.

Arguments

This endpoint takes no JSON arguments.

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 "https://api.datadoghq.com/api/v1/logs/config/pipeline-order?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
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 Indexes Order

This endpoint is in public beta. If you have any feedback, contact Datadog support.

This endpoint updates the IndexOrder of your organization. It returns the IndexOrder object passed in the request body when the request is successful.

Arguments
  • index_names [required]: Array of Strings identifying by their name(s) the index(es) of your organisation. Logs are tested against the query filter of each index one by one, following the order of the array. Logs are eventually stored in the first matching index.
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 "https://api.datadoghq.com/api/v1/logs/config/pipeline-order?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json' \
  -d '{
    "pipeline_ids": [
        "<PIPELINE_1_ID>",
        "<PIPELINE_2_ID>",
        "<PIPELINE_3_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
{
    "pipeline_ids": [
        "<PIPELINE_1_ID>",
        "<PIPELINE_2_ID>",
        "<PIPELINE_3_ID>"
    ]
}

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.

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 "https://api.datadoghq.com/api/v1/logs/config/pipelines?api_key=${api_key}&application_key=${app_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
[
    {
        "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 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/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 "https://api.datadoghq.com/api/v1/logs/config/${pipeline_id}?api_key=${api_key}&application_key=${app_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
{
    "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"
        }
    ]
}
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 Pipeline Order

Update the order of your Pipelines.

Note: Logs are processed sequentially. Reordering a pipeline may change the structure and content of the data processed by other pipelines and their processors.

Arguments
  • pipeline_ids [required]: Ordered Array of <PIPELINE_ID> strings, the order of pipeline IDs in the array define the overall Pipelines order for Datadog?
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 \
  "https://api.datadoghq.com/api/v1/logs/config/pipelines?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json' \
  -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"
        }
    ]
}'
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"
        }
    ]
}

Obtenir toutes les pipelines

Obtenez tous les pipelines de votre organisation.

Arguments

Cet endpoint ne prend aucun argument JSON.

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 \
  "https://api.datadoghq.com/api/v1/logs/config/pipelines/${pipeline_id}?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json' \
  -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"
        }
    ]
}'
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"
        }
    ]
}

Obtenir un pipeline

Obtenez un pipeline spécifique 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 "https://api.datadoghq.com/api/v1/logs/config/pipelines/${pipeline_id}?api_key=${api_key}&application_key=${app_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
{}

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.

Mettre à jour un pipeline

Mettez à jour une configuration de pipeline donnée pour modifier ses processeurs ou leur ordre.

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

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 -v -1d +%s)

curl -G \
    "https://api.datadoghq.com/api/v1/metrics" \
    -d "api_key=${api_key}" \
    -d "application_key=${app_key}" \
    -d "from=${from_time}" \
    -d "host=<HOSTNAME>"
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
}

Supprimer un pipeline

Supprimez un pipeline donné de votre organisation.

Arguments

Cet endpoint ne prend aucun argument JSON.

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>"

Métriques

L’endpoint métrique vous permet de :

  • Envoyez vos données de métriques afin de les afficher sur les tableaux de bord 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.

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 -v -1d +%s)

curl -G \
    "https://api.datadoghq.com/api/v1/query" \
    -d "api_key=${api_key}" \
    -d "application_key=${app_key}" \
    -d "from=${from_time}" \
    -d "to=${to_time}" \
    -d "query=system.cpu.idle{*}by{host}"
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": ""
}

Récupérer la liste des métriques actives

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/<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 "https://api.datadoghq.com/api/v1/metrics/${metric_name}?api_key=${api_key}&application_key=${app_key}"

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"
}

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).

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

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" \
-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}?api_key=${api_key}&application_key=${app_key}"

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"
}

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/search

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(q="metrics:system")
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:system")
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -G "https://api.datadoghq.com/api/v1/search" \
    -d "api_key=${api_key}" \
    -d "application_key=${app_key}" \
    -d "q=metrics:test"

Exemple de réponse

{
    'results': {
        'metrics': [
            'test.metric.metric',
            'test.tag.metric'
        ]
    }
}
["200", {
    "results" => {
        "metrics" => ["test.metric"]
    }
}]
{
  "results": {
    "metrics": [
      "test.metric"
    ]
  }
}

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.

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

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" \
-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?api_key=${api_key}&application_key=${app_key}"
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"
}

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. Doit commencer par metrics:.
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 -G "https://api.datadoghq.com/api/v1/monitor/${monitor_id}" \
     -d "api_key=${api_key}" \
     -d "application_key=${app_key}" \
     -d "group_states=all"
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
        }
      }
    }
  }
}

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.

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" \
-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}?api_key=${api_key}&application_key=${app_key}"
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"}

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 envoyer une notification pour les statuts 1 Critical, 3 Ok et 2 Warning, « count » doit prendre pour valeur 3.
    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 utiliser des seuils d’annulation pour 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

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 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

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 -G "https://api.datadoghq.com/api/v1/monitor" \
     -d "api_key=${api_key}" \
     -d "application_key=${app_key}"
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":""
      }
   }
]

Modifier un monitor

ARGUMENTS
  • query [obligatoire] : La requête de la métrique pour laquelle les alertes sont envoyées.
  • name [obligatoire] : 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

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" \
-d '{
"resolve": [
          {"<YOUR_MONITOR_ID>": "<YOUR_FIRST_GROUP>"},
          {"<YOUR_MONITOR_ID>": "<YOUR_SECOND_GROUP>"}
      ]
}' \
    "https://app.datadoghq.com/monitor/bulk_resolve?api_key=${api_key}&application_key=${app_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
[
  {
    "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
      }
    }
  }
]

Supprimer un monitor

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" "https://api.datadoghq.com/api/v1/monitor/mute_all?api_key=${api_key}&application_key=${app_key}"
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é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’information, 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.
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" "https://api.datadoghq.com/api/v1/monitor/unmute_all?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse

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

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 /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" "https://api.datadoghq.com/api/v1/monitor/${monitor_id}/mute?api_key=${api_key}&application_key=${app_key}"
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"
}

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/<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 "https://api.datadoghq.com/api/v1/monitor/${monitor_id}/unmute?api_key=${api_key}&application_key=${app_key}"
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"
}

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/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" \
-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?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{}
["200", {}]
{
    "errors": [
        "The value provided for parameter 'query' is invalid"
    ]
}

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

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 \
    "https://api.datadoghq.com/api/v1/monitor/search?api_key=${api_key}&application_key=${app_key}&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
  }
}

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

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 \
    "https://api.datadoghq.com/api/v1/monitor/groups/search?api_key=${api_key}&application_key=${app_key}&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
  }
}

Valider un monitor

Valide la définition d’un monitor (consultez Créer un monitor pour obtenir plus d’informations sur l’élaboration d’une définition de monitor).

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

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" \
    -d '{
        "name" :"My Org",
        "subscription" :{"type":"pro"},
        "billing" :{"type":"parent_billing"}
}' \
    "https://api.datadoghq.com/api/v1/org?api_key=${api_key}&application_key=${app_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
{
  "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",
    ...
  }
}

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/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 "https://api.datadoghq.com/api/v1/org?api_key=${api_key}&application_key=${app_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
{
  "orgs" : [{
      "name" : "My Org",
      "public_id" : "axd2s",
      "subscription" : {
        "type" : "pro"
      },
      "billing" : {
        "type" : "bill-parent"
    }
  }]
}

Organisations

Créez, modifiez et gérez vos organisations. En savoir plus sur les comptes multi-org.

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" \
    -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}?api_key=${api_key}&application_key=${app_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
{
  "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"
    }
  }
}

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/<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" \
    -F "idp_file=@metadata.xml" \
    "https://api.datadoghq.com/api/v1/org/${public_id}/idp_metadata?api_key=${api_key}&application_key=${app_key}"

# OR

# Upload IdP file using application/xml
curl -X POST -H "Content-Type: application/xml" \
    --data-binary "@metadata.xml" \
    "https://api.datadoghq.com/api/v1/org/${public_id}/idp_metadata?api_key=${api_key}&application_key=${app_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
{
  "message": "IdP metadata successfully uploaded for org Datadog HQ"
}

Récupérer une organisation

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 « @ ».

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/synthetics/tests/

Exemple de requête
# This is not yet supported by the Python Client for the Datadog API
# This is not yet supported by the Ruby Client for the Datadog API
### To create an API test

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST \
  "https://api.datadoghq.com/api/v1/synthetics/tests?api_key=${api_key}&application_key=${app_key}" \
  -H 'Content-Type: application/json' \
  -d '{
   "config":{
      "assertions":[
         {
            "operator":"is",
            "type":"statusCode",
            "target":403
         },
         {
            "operator":"is",
            "property":"content-type",
            "type":"header",
            "target":"text/html"
         },
         {
            "operator":"lessThan",
            "type":"responseTime",
            "target":2000
         }
      ],
      "request":{
         "method":"GET",
         "url":"https://datadoghq.com",
         "timeout":30,
         "headers":{
            "header1":"value1",
            "header2":"value2"
         },
         "body":"body to send with the request"
      }
   },
   "locations":[
      "aws:us-east-2",
      "aws:eu-central-1",
      "aws:ca-central-1",
      "aws:eu-west-2",
      "aws:ap-northeast-1",
      "aws:us-west-2",
      "aws:ap-southeast-2"
   ],
   "message":"test",
   "name":"Test",
   "options":{
      "tick_every":60,
      "min_failure_duration":0,
      "min_location_failed":1,
      "follow_redirects":true
   },
   "tags":[
      "foo:bar"
   ],
   "type":"api"
}'

### To create a browser test

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl  -X POST -H "Content-type: application/json" \
-d '{
   "locations":[
      "aws:ca-central-1",
      "aws:us-east-2"
   ],
   "options":{
      "device_ids":[
         "laptop_large"
      ],
      "tick_every":3600,
      "min_failure_duration":0,
      "min_location_failed":1
   },
   "name":"Test Doc",
   "config":{
      "assertions":[

      ],
      "request":{
         "method":"GET",
         "url":"https://example.com/"
      }
   },
   "message":"Test message",
   "tags":[

   ],
   "type":"browser"
}' \
"https://api.datadoghq.com/api/v1/synthetics/tests?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{  
   "status":"live",
   "public_id":"sti-s2m-ciz",
   "tags":[  
      "foo:bar"
   ],
   "locations":[  
      "aws:us-east-2",
      "aws:eu-central-1",
      "aws:ca-central-1",
      "aws:eu-west-2",
      "aws:ap-northeast-1",
      "aws:us-west-2",
      "aws:ap-southeast-2"
   ],
   "message":"test",
   "deleted_at":null,
   "name":"Test",
   "type":"api",
   "created_at":"2019-04-18T14:35:28.378610+00:00",
   "modified_at":"2019-04-18T14:35:28.378610+00:00",
   "config":{  
      "request":{  
         "url":"https://datadoghq.com",
         "headers":{  
            "header2":"value2",
            "header1":"value1"
         },
         "body":"body to send with the request",
         "method":"GET",
         "timeout":30
      },
      "assertions":[  
         {  
            "operator":"is",
            "type":"statusCode",
            "target":403
         },
         {  
            "operator":"is",
            "property":"content-type",
            "type":"header",
            "target":"text/html"
         },
         {  
            "operator":"lessThan",
            "type":"responseTime",
            "target":2000
         }
      ]
   },
   "options":{  
      "follow_redirects":true,
      "min_failure_duration":0,
      "tick_every":60,
      "min_location_failed":1
   }
}

Screenboards

Cet endpoint est obsolète. Utilisez plutôt le nouvel endpoint Dashboards.
Signature

POST /v1/synthetics/tests/<ID_PUBLIC_TEST_SYNTHETICS>/status

Exemple de requête
# This is not yet supported by the Python Client for the Datadog API
# This is not yet supported by the Ruby Client for the Datadog API
#!/bin/bash

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
public_id=<SYNTHETICS_TEST_PUBLIC_ID>

curl -X PUT -H "Content-type: application/json" \
-d '{"new_status":"paused"}' \
"https://api.datadoghq.com/api/v1/synthetics/tests/${public_id}/status?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
true

Synthetics

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

Datadog Synthetics utilise des requêtes utilisateur simulées et du rendu de navigateur pour vous aider à garantir la disponibilité, à identifier les problèmes par région et à suivre les performances de l’application.

Vous pouvez utiliser l’API Datadog pour créer des tests de programmation de l’API Synthetics. Les tests de l’API sont des requêtes HTTP (GET, POST, PUT, PATCH, DELETE) exécutées par Datadog vers vos propriétés Web ou endpoints d’application à des intervalles configurables depuis différentes localisations dans le monde. Ces checks vérifient que vos applications répondent aux requêtes, tout en respectant les conditions que vous avez définies, comme le délai de réponse, le code de statut HTTP, ainsi que les contenus de l’en-tête et du corps de message.

Pour en savoir plus sur Synthetics, consultez la présentation Synthetics.

Signature

PUT /v1/synthetics/tests/<ID_PUBLIC_TEST_SYNTHETICS>

Exemple de requête
# This is not yet supported by the Python Client for the Datadog API
# This is not yet supported by the Ruby Client for the Datadog API
#!/bin/bash

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
public_id=<SYNTHETICS_TEST_PUBLIC_ID>

curl -X PUT -H "Content-type: application/json" \
-d '{
   "config":{
      "assertions":[
         {
            "operator":"is",
            "type":"statusCode",
            "target":403
         },
         {
            "operator":"is",
            "property":"content-type",
            "type":"header",
            "target":"text/html"
         },
         {
            "operator":"lessThan",
            "type":"responseTime",
            "target":2000
         }
      ],
      "request":{
         "method":"GET",
         "url":"https://datadoghq.com",
         "timeout":30,
         "headers":{
            "header1":"value1",
            "header2":"value2"
         },
         "body":"body to send with the request"
      }
   },
   "locations":[
      "aws:us-east-2",
      "aws:eu-central-1",
      "aws:ca-central-1",
      "aws:eu-west-2",
      "aws:ap-northeast-1",
      "aws:us-west-2",
      "aws:ap-southeast-2"
   ],
   "message": "test-edited",
   "name":"Test",
   "options":{
      "tick_every":60,
      "min_failure_duration":0,
      "min_location_failed":1,
      "follow_redirects":true
   },
   "tags":[
      "foo:bar"
   ],
   "type":"api"
}' \
"https://api.datadoghq.com/api/v1/synthetics/tests/${public_id}?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{  
   "status":"live",
   "public_id":"aaa-bbb-ccc",
   "tags":[  
      "foo:bar"
   ],
   "locations":[  
      "aws:us-east-2",
      "aws:eu-central-1",
      "aws:ca-central-1",
      "aws:eu-west-2",
      "aws:ap-northeast-1",
      "aws:us-west-2",
      "aws:ap-southeast-2"
   ],
   "message":"test-edited",
   "deleted_at":null,
   "name":"Test",
   "type":"api",
   "created_at":"2019-04-12T12:29:34.379537+00:00",
   "modified_at":"2019-04-12T12:29:34.379537+00:00",
   "config":{  
      "request":{  
         "url":"https://datadoghq.com",
         "headers":{  
            "sdf":"fds",
            "Cookie":"qds"
         },
         "body":"fs",
         "method":"GET",
         "timeout":30
      },
      "assertions":[  
         {  
            "operator":"is",
            "type":"statusCode",
            "target":403
         },
         {  
            "operator":"is",
            "property":"content-type",
            "type":"header",
            "target":"text/html"
         },
         {  
            "operator":"lessThan",
            "type":"responseTime",
            "target":2000
         }
      ]
   },
   "options":{  
      "follow_redirects":true,
      "min_failure_duration":0,
      "tick_every":60,
      "min_location_failed":1
   }
}

Créer un test

Créez un test Synthetics pour initier et configurer les tests que vous souhaitez envoyer par Datadog à vos endpoints API ou à votre application de navigateur. Vous pouvez configurer les endpoints testés, le nombre de tests, ainsi que leur source. Les paramètres requis sont différents pour les tests d’API et de navigateur et ils sont marqués en fonction. Si un paramètre est marqué comme obligatoire, il est obligatoire pour les deux types de tests. Une fois un test créé, il s’affiche dans l’interface graphique de votre liste Synthetics.

Un test de navigateur est traité comme un test GET API. Cette méthode vous permet de créer un test de navigateur, mais vous devez utiliser l’interface graphique pour enregistrer votre test.

Arguments
  • assertions (obligatoire) : ce paramètre permet de définir exactement ce qui doit se produire pour qu’un test soit considéré comme réussi. Chaque assertion dispose des éléments suivants : type, operator, target et éventuellement une property.
    • type (test API obligatoire) : la partie de la réponse que vous souhaitez évaluer. Les types possibles sont header, body, responseTime et statusCode. Lorsque vous définissez un en-tête, vous devez indiquer la clé du paramètre d’en-tête dans le paramètre property et la valeur du paramètre d’en-tête avec le paramètre target. Pour tous les autres types, utilisez target pour spécifier le corps, le délai de réponse et les messages d’erreur. Par exemple, "type":"statusCode" peut avoir "target":403.
    • operator (test API obligatoire) : définit comment comparer la cible et la valeur actuelle depuis la réponse. Les opérateurs valides dépendent du type d’assertions. Voici une liste des opérateurs valides par type :
typeoperator valideType de valeur
Code de statutis, is notNombre entier
Délai de réponselessThanNombre entier
En-têtescontains, does not contain, is, is not, matches, does not matchpour contains/does not contain/is/is not : Chaîne Pour matches/does not match : RegexString
Corpscontains, does not contain, is, is not, matches, does not matchPour contains/does not contain/is/is not : Chaîne Pour matches/does not match : RegexString
  • target (test API obligatoire) : la valeur attendue de l’assertion. Pour header, les valeurs valides sont toutes les valeurs valides de la clé d’en-tête définies dans property. Pour statusCode, les valeurs valides sont les codes de statuts valides. Pour responseTime, les valeurs valides sont les délais de réponse attendus.
  • property (obligatoire) : lorsque vous configurez un type header, ce paramètre est obligatoire pour définir la clé des paramètres des en-têtes. Les valeurs valides sont toutes les clés d’en-tête, telles que Content-Type ou Authorization.
  • request (test API obligatoire) : un objet contenant toutes les informations nécessaires pour effectuer la requête sur votre endpoint.
    • method (obligatoire) : la méthode d’API à tester. Les valeurs valides sont GET, POST, PUT, PATCH et DELETE. Utilisez GET pour un test de navigateur.
    • url (obligatoire) : l’endpoint de l’API que Datadog est en train de tester. Pour un test Browser, l’URL du site web testé par Datadog.
    • timeout (facultatif) : lorsque la requête API va expirer.
    • headers (facultatif) : en-têtes dans la requête API.
    • body (facultatif) : le corps de la requête API. Accepte des chaînes de texte (y compris un JSON comme chaîne de texte). Spécifiez le type en utilisant le paramètre property Content-Type et le type (comme application/json ou text/plain dans le paramètre headers.
  • locations (obligatoire) : une liste de localisations à partir desquelles vous souhaitez envoyer les tests. Une valeur au moins est obligatoire et vous pouvez utiliser toutes les localisations. Pour une liste de localisations valides, utilisez la méthode GET available locations. Vous devez saisir au moins une valeur et vous pouvez utiliser toutes les localisations.
  • message (obligatoire) : une description du test.
  • name (obligatoire) : un nom unique pour le test.
  • options (obligatoire) : utilisez les options avancées pour indiquer les en-têtes des requêtes personnalisées, les identifiants de connexion, le contenu du corps, les cookies ou les redirections de suivi de test. Tous les paramètres en option ont leur valeur par défaut si vous n’indiquez pas de valeur. Les valeurs valides dans l’objet de requête sont :
    • ** tick_every:** (obligatoire) : la fréquence d’exécution du test (en secondes, valeurs possibles : 60, 300, 900, 1800, 3600, 21600, 43200, 86400, 604800).
    • min_failure_duration (facultatif) : la durée pendant laquelle le test doit être en état d’échec avant qu’une alerte soit envoyée (nombre entier, nombre de secondes, max. 7200). La valeur par défaut est 0.
    • min_location_failed (facultatif) : le nombre minimum de localisations qui doivent être en échec en même temps pendant au moins un moment donné dans la période min_failure_duration (min_location_failed et min_failure_duration font parti des règles d’alerte avancées - nombre entier, >= 1. Valeur par défaut : 1.
    • follow_redirects (facultatif) : indique s’il faut suivre ou non les redirections (booléen). Jusqu’à dix redirections peuvent être suivies avant de déclencher l’erreur « Too many redirects ». Les valeurs valides sont true ou false. Valeur par défaut : false.
    • device_ids (test de navigateur obligatoire) : le type d’appareil que vous souhaitez utiliser pour effectuer le test. Utilisez la méthode GET devices for browser checkes pour obtenir une liste des appareils disponibles et utilisez l’id depuis la réponse. Vous devez indiquer au moins un appareil.
  • tags (facultatif) : les tags que vous souhaitez utiliser pour filtrer votre test lorsque vous le visualisez dans Datadog. Pour en savoir plus sur les tags personnalisés, consultez Utilisation des tags.
  • type (obligatoire) : le type de test. Les valeurs valides sont api et browser.
Signature

POST /v1/synthetics/tests/delete

Exemple de requête
# This is not yet supported by the Python Client for the Datadog API
# This is not yet supported by the Ruby Client for the Datadog API
#!/bin/bash

api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl -X POST -H "Content-type: application/json" \
-d '{
   "public_ids":[
      "aaa-bbb-ccc",
      "bbb-ccc-ddd"
   ]
}' \
"https://api.datadoghq.com/api/v1/synthetics/tests/delete?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{  
   "deleted_tests":[  
      {  
         "public_id":"262647",
         "deleted_at":"2019-04-16T21:20:57+0000"
      },
      {  
         "public_id":"262648",
         "deleted_at":"2019-04-16T21:20:57+0000"
      }
   ]
}

Démarrer ou interrompre un test

Utilisez cette méthode pour démarrer ou interrompre un test Synthetics existant.

Arguments
  • new_status - obligatoire - Une paire clé-valeur dans laquelle vous définissez si vous souhaitez démarrer ou interrompre un test. Les valeurs valides sont live et paused. Renvoie true si le statut a été modifié etfalse si le statut est resté identique.
Signature

GET /v1/synthetics/tests/<ID_PUBLIC_TEST_SYNTHETICS>/results

Exemple de requête
# This is not yet supported by the Python Client for the Datadog API
# This is not yet supported by the Ruby Client for the Datadog API
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
public_id=<SYNTHETICS_TEST_PUBLIC_ID>

curl "https://api.datadoghq.com/api/v1/synthetics/tests/${public_id}/results?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{  
   "last_timestamp_fetched":1555073253000,
   "results":[  
      {  
         "status":0,
         "probe_dc":"aws:eu-central-1",
         "result_id":"13240452786084775503",
         "result":{  
            "timings":{  
               "firstByte":563.9,
               "tcp":28.8,
               "ssl":60.4,
               "dns":1.0678250044584274,
               "download":0.1,
               "total":654.3
            }
         },
         "check_time":1555074213964
      }
   ]
}

Modifier un test

Utilisez cette méthode pour mettre à jour un test Synthetics existant. Vous devez envoyer la même charge utile que celle de création d’un test pour mettre à jour un test.

Les paramètres requis sont différents pour les tests Browser et d’API. Ils sont marqués comme suit : si un paramètre est marqué comme obligatoire, il est requis pour les deux types de tests.

Un test Browser est traité comme un test d’API GET. Cette méthode vous permet de mettre à jour le test Browser, mais vous devez utiliser l’IU pour enregistrer votre test.

Vous devez envoyer un objet complet afin de mettre à jour la requête. Seuls ces paramètres sont modifiables : name, tags, config (tous les paramètres définis dans assertions et dans request), message, options, locations et status.

Arguments
  • assertions (obligatoire) : ce paramètre permet de définir exactement ce qui doit se produire pour qu’un test soit considéré comme réussi. Chaque assertion dispose des éléments suivants : type, operator, target et éventuellement une property.
    • type (test d’API obligatoire) : la partie de la réponse que vous souhaitez évaluer. Les types possibles sont header, body, responseTime et statusCode. Lorsque vous définissez un en-tête, vous devez indiquer la clé du paramètre d’en-tête dans le paramètre property et la valeur du paramètre d’en-tête avec le paramètre target. Pour tous les autres types, utilisez target pour spécifier le corps, le délai de réponse et les messages d’erreur. Par exemple, "type":"statusCode" peut avoir "target":403.
    • operator (test d’API obligatoire) : définie comment comparer la cible et la valeur actuelle depuis la réponse. Les opérateurs valides dépendent du type d’assertions. Voici une liste des opérateurs valides par type :
typeopérateur valideType de valeur
Code de statutis, is notNombre entier
Délai de réponseless thanNombre entier
En-têtescontains, does not contain, is, is not, matches, does not matchpour contains/does not contain/is/is not : Chaîne Pour matches/does not match : RegexString
Corpscontains, does not contain, is, is not, matches, does not matchPour contains/does not contain/is/is not : Chaîne Pour matches/does not match : RegexString
  • target (test d’API obligatoire) : la valeur attendue de l’assertion. Pour header, les valeurs valides sont toutes les valeurs valides de la clé d’en-tête définies dans property. Pour statusCode, les valeurs valides sont les codes de statuts valides. Pour responseTime, les valeurs valides sont les délais de réponse attendus.
  • property (obligatoire) : lorsque vous configurez un type header, ce paramètre est obligatoire pour définir la clé des paramètres des en-têtes. Les valeurs valides sont toutes les clés d’en-tête, telles que Content-Type ou Authorization.
  • request (test d’API obligatoire) : un objet contenant toutes les informations nécessaires pour effectuer la requête sur votre endpoint.
    • method (obligatoire) : la méthode d’API à tester. Les valeurs valides sont GET, POST, PUT, PATCH et DELETE. Utilisez GET pour un test Browser.
    • url (obligatoire) : l’endpoint de l’API que Datadog est en train de tester. Pour un test Browser, l’URL du site web testée par Datadog.
    • timeout (facultatif) : indique le moment où la requête API va expirer.
    • headers (facultatif) : en-têtes dans la requête API.
    • body (facultatif) : le corps de la requête API. Accepte les chaînes de texte (notamment un fichier JSON en tant que chaîne de texte). Indiquez le type à l’aide du paramètre Content-Type property et le type (comme application/json ou text/plain dans le paramètre headers).
  • locations (obligatoire) : une liste de localisations à partir desquelles vous souhaitez envoyer les tests. Une valeur au moins est obligatoire et vous pouvez utiliser toutes les localisations. Pour une liste de localisations valides, utilisez la méthode GET available locations. Vous devez saisir au moins une valeur et vous pouvez utiliser toutes les localisations.
  • message (obligatoire) : une description du test.
  • name (obligatoire) : un nom unique pour le test.
  • options (obligatoire) : utilisez les options avancées pour indiquer les en-têtes des requêtes personnalisées, les identifiants de connexion, le contenu du corps, les cookies ou les redirections de suivi de test. Tous les paramètres en option utilisent leur valeur par défaut si vous n’indiquez pas de valeur. Les valeurs valides dans l’objet de requête sont :
    • tick_every: (obligatoire) : la fréquence à laquelle le test doit s’exécuter. Les valeurs actuelles possibles sont 60, 300, 900, 1 800, 3 600, 21 600, 43 200, 86 400, 604 800 (en secondes).
    • min_failure_duration (facultatif) : la durée pendant laquelle le test doit être en état d’échec avant qu’une alerte soit envoyée (nombre entier, nombre de secondes, max. 7 200). La valeur par défaut est 0.
    • min_location_failed (facultatif) : le nombre minimum de localisations qui doivent être en échec en même temps pendant au moins un moment donné dans la période min_failure_duration (min_location_failed et min_failure_duration font partie des règles d’alerte avancées - nombre entier, >= 1. Valeur par défaut : 1.
    • follow_redirects (facultatif) : indique s’il faut suivre ou non les redirections (booléen). Jusqu’à dix redirections peuvent être suivies avant de déclencher l’erreur « Too many redirects ». Les valeurs valides sont true ou false. Valeur par défaut : false.
    • device_ids (test Browser obligatoire) : le type d’appareil que vous souhaitez utiliser pour effectuer le test. Utilisez la méthode GET devices for browser checkes pour obtenir une liste des appareils disponibles et utilisez l’id depuis la réponse. Vous devez indiquer au moins un appareil.
  • tags (facultatif) : les tags que vous souhaitez utiliser pour filtrer votre test lorsque vous le visualisez dans Datadog. Pour obtenir plus d’informations sur les tags personnalisés, consultez Utiliser les tags.
  • type (obligatoire) : le type de test. Les valeurs valides sont api et browser.
Signature

GET /v1/synthetics/tests/<ID_PUBLIC_TEST_SYNTHETICS>/results/<ID_RÉSULTAT>

Exemple de requête
# This is not yet supported by the Python Client for the Datadog API
# This is not yet supported by the Ruby Client for the Datadog API
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
public_id=<SYNTHETICS_TEST_PUBLIC_ID>
result_id=<TEST_RESULT_ID>

curl "https://api.datadoghq.com/api/v1/synthetics/tests/${public_id}/results/${result_id}?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{  
   "status":0,
   "check_time":1555074753734,
   "check_version":4,
   "result":{  
      "timings":{  
         "firstByte":717.5,
         "tcp":281.8,
         "ssl":565.2,
         "dns":1.103536993265152,
         "download":0.1,
         "total":1565.7
      },
      "mainDC":"us1.prod",
      "eventType":"finished",
      "httpStatusCode":200,
      "responseSize":26693
   },
   "probe_dc":"aws:ap-northeast-1",
   "result_id":"16334500735347249235",
   "check":{  
      "config":{  
         "request":{  
            "url":"https://datadoghq.com/",
            "method":"GET",
            "timeout":30
         },
         "assertions":[  
            {  
               "operator":"is",
               "type":"statusCode",
               "target":200
            }
         ]
      }
   }
}

Supprimer des tests

Utilisez cette méthode pour supprimer des tests.

Arguments
  • public_ids - obligatoire - Liste JSON de l’ID ou des ID des tests que vous souhaitez supprimer.
Signature

GET /v1/synthetics/tests

Exemple de requête
# This is not yet supported by the Python Client for the Datadog API
# This is not yet supported by the Ruby Client for the Datadog API
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl "https://api.datadoghq.com/api/v1/synthetics/tests?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{  
   "tests":[  
      {  
         "status":"live",
         "public_id":"84r-szk-xpt",
         "tags":[  
            "foo:bar"
         ],
         "locations":[  
            "aws:us-east-2",
            "aws:eu-central-1",
            "aws:ca-central-1",
            "aws:eu-west-2",
            "aws:ap-northeast-1",
            "aws:us-west-2",
            "aws:ap-southeast-2"
         ],
         "message":"test",
         "name":"Test",
         "type":"api",
         "created_at":"2019-04-18T14:31:04.087360+00:00",
         "modified_at":"2019-04-18T14:31:04.087360+00:00",
         "config":{  
            "request":{  
               "url":"https://datadoghq.com",
               "headers":{  
                  "header2":"value2",
                  "header1":"value1"
               },
               "body":"body to send with the request",
               "method":"GET",
               "timeout":30
            },
            "assertions":[  
               {  
                  "operator":"is",
                  "type":"statusCode",
                  "target":403
               },
               {  
                  "operator":"is",
                  "property":"content-type",
                  "type":"header",
                  "target":"text/html"
               },
               {  
                  "operator":"lessThan",
                  "type":"responseTime",
                  "target":2000
               }
            ]
         },
         "options":{  
            "follow_redirects":true,
            "min_failure_duration":0,
            "tick_every":60,
            "min_location_failed":1
         }
      },
      {  
         "status":"paused",
         "public_id":"sti-hyu-ciz",
         "tags":[  
            "foo:bar"
         ],
         "locations":[  
            "aws:us-east-2",
            "aws:eu-central-1",
            "aws:ap-northeast-1",
            "aws:us-west-2",
            "aws:ap-southeast-2"
         ],
         "message":"test-edited",
         "name":"Test",
         "type":"api",
         "created_at":"2019-04-18T14:35:28.378610+00:00",
         "modified_at":"2019-04-18T15:04:56.181518+00:00",
         "config":{  
            "request":{  
               "url":"https://datadoghq.com",
               "headers":{  
                  "header2":"value2",
                  "header1":"value1"
               },
               "body":"body to send with the request",
               "method":"GET",
               "timeout":30
            },
            "assertions":[  
               {  
                  "operator":"is",
                  "type":"statusCode",
                  "target":403
               },
               {  
                  "operator":"is",
                  "property":"content-type",
                  "type":"header",
                  "target":"text/html"
               },
               {  
                  "operator":"lessThan",
                  "type":"responseTime",
                  "target":2000
               }
            ]
         },
         "options":{  
            "follow_redirects":true,
            "min_failure_duration":0,
            "tick_every":60,
            "min_location_failed":1
         }
      },
      {  
         "status":"paused",
         "public_id":"s6z-mno-2g6",
         "tags":[  

         ],
         "locations":[  
            "aws:ca-central-1",
            "aws:us-east-2"
         ],
         "message":"Test message",
         "name":"Test Doc",
         "type":"browser",
         "created_at":"2019-04-18T14:39:38.057734+00:00",
         "modified_at":"2019-04-18T14:39:38.057734+00:00",
         "config":{  
            "request":{  
               "url":"https://docs.datadoghq.com/",
               "method":"GET"
            },
            "assertions":[  

            ]
         },
         "options":{  
            "min_failure_duration":0,
            "device_ids":[  
               "laptop_large"
            ],
            "tick_every":3600,
            "min_location_failed":1
         }
      }
   ]
}

Obtenir les résultats les plus récents

Utilisez cette méthode pour obtenir les résultats les plus récents pour un test en particulier.

Arguments

Cet endpoint ne prend aucun argument JSON.

Signature

GET /v1/synthetics/tests/<ID_PUBLIC_TEST_SYNTHETICS>

Exemple de requête
# This is not yet supported by the Python Client for the Datadog API
# This is not yet supported by the Ruby Client for the Datadog API
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
public_id=<SYNTHETICS_TEST_PUBLIC_ID>

curl "https://api.datadoghq.com/api/v1/synthetics/tests/${public_id}?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{  
   "status":"live",
   "public_id":"84r-szk-xpt",
   "tags":[  
      "foo:bar"
   ],
   "locations":[  
      "aws:us-east-2",
      "aws:eu-central-1",
      "aws:ca-central-1",
      "aws:eu-west-2",
      "aws:ap-northeast-1",
      "aws:us-west-2",
      "aws:ap-southeast-2"
   ],
   "message":"test",
   "modified_by":{  
      "email":"example@example.com",
      "handle":"example@example.com",
      "id":1226568,
      "name":"Jane Doe"
   },
   "name":"Test",
   "type":"api",
   "created_at":"2019-04-18T14:31:04.087360+00:00",
   "modified_at":"2019-04-18T14:31:04.087360+00:00",
   "created_by":{  
      "email":"example@example.com",
      "handle":"example@example.com",
      "id":1226568,
      "name":"Jane Doe"
   },
   "overall_state_modified":"2019-04-18T14:31:23.689576+00:00",
   "overall_state":0,
   "config":{  
      "request":{  
         "url":"https://datadoghq.com",
         "headers":{  
            "header2":"value2",
            "header1":"value1"
         },
         "body":"body to send with the request",
         "method":"GET",
         "timeout":30
      },
      "assertions":[  
         {  
            "operator":"is",
            "type":"statusCode",
            "target":403
         },
         {  
            "operator":"is",
            "property":"content-type",
            "type":"header",
            "target":"text/html"
         },
         {  
            "operator":"lessThan",
            "type":"responseTime",
            "target":2000
         }
      ]
   },
   "options":{  
      "follow_redirects":true,
      "min_failure_duration":0,
      "tick_every":60,
      "min_location_failed":1
   }
}
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 specific result

Use this method to get a specific result for a specific test.

Arguments

This endpoint takes no JSON arguments.

Signature

GET /v1/synthetics/browser/devices

Exemple de requête
# This is not yet supported by the Python Client for the Datadog API
# This is not yet supported by the Ruby Client for the Datadog API
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl "https://api.datadoghq.com/api/v1/synthetics/browser/devices?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{  
   "devices":[  
      {  
         "width":1440,
         "height":1100,
         "id":"laptop_large",
         "isMobile":false,
         "name":"Laptop Large"
      },
      {  
         "width":768,
         "height":1020,
         "id":"tablet",
         "isMobile":true,
         "name":"Tablet"
      },
      {  
         "width":320,
         "height":550,
         "id":"mobile_small",
         "isMobile":true,
         "name":"Mobile Small"
      }
   ]
}


Obtenir tous les test

Utilisez cette méthode pour obtenir une liste de tous les tests existants.

Arguments

Cet endpoint ne prend aucun argument JSON.

Signature

GET /v1/synthetics/locations

Exemple de requête
# This is not yet supported by the Python Client for the Datadog API
# This is not yet supported by the Ruby Client for the Datadog API
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl "https://api.datadoghq.com/api/v1/synthetics/locations?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{  
   "locations":[  
      {  
         "is_active":true,
         "region":"Americas",
         "display_name":"Ohio (AWS)",
         "id":30005,
         "name":"aws:us-east-2"
      },
      {  
         "is_active":true,
         "region":"Europe",
         "display_name":"Frankfurt (AWS)",
         "id":3,
         "name":"aws:eu-central-1"
      },
      {  
         "is_active":true,
         "region":"Americas",
         "display_name":"Canada Central (AWS)",
         "id":30003,
         "name":"aws:ca-central-1"
      },
      {  
         "is_active":true,
         "region":"Europe",
         "display_name":"London (AWS)",
         "id":2,
         "name":"aws:eu-west-2"
      },
      {  
         "is_active":true,
         "region":"Asia Pacific",
         "display_name":"Tokyo (AWS)",
         "id":4,
         "name":"aws:ap-northeast-1"
      },
      {  
         "is_active":true,
         "region":"Americas",
         "display_name":"Oregon (AWS)",
         "id":1,
         "name":"aws:us-west-2"
      },
      {  
         "is_active":true,
         "region":"Asia Pacific",
         "display_name":"Sydney (AWS)",
         "id":30004,
         "name":"aws:ap-southeast-2"
      }
   ]
}

Obtenir un test

Utilisez cette méthode pour obtenir des informations relatives à un test en particulier.

Arguments

Cet endpoint ne prend aucun argument JSON.

Obtenir des appareils pour les checks Browser

Obtenir une liste des appareils pour les checks Browser.

Arguments

Cet endpoint ne prend aucun argument JSON.

Signature

GET /v1/tags/hosts

Exemple de requête
from datadog import initialize, api

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

initialize(**options)

print api.Tag.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.all_tags()
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

curl "https://api.datadoghq.com/api/v1/tags/hosts?api_key=${api_key}&application_key=${app_key}"

Exemple de réponse


{
    "tags": {
        "role:database",
        "env:test": [
            "test.metric.host"
        ]
    }
}
["200", {
    "tags" => {
        "role:web" => ["test.metric.host"],
        "environment:test" => ["test.metric.host"],
        "environment:production" => ["test.another.example.com"],
        "role:webserver" => ["test.another.example.com"]
    }
}]
{
  "tags": {
    "environment:production": [
      "test.another.example.com",
      "test.host"
    ],
    "environment:test": [
      "test.metric.host"
    ],
    "role:database": [
      "test.metric.host"
    ],
    "role:webserver": [
      "test.another.example.com",
      "test.host"
    ]
  }
}

Obtenir des localisations disponibles

Obtenir une liste des localisations disponibles

Arguments

Cet endpoint ne prend aucun argument JSON.

Signature

GET /v1/tags/hosts/<HOSTNAME>

Exemple de requête
from datadog import initialize, api

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

initialize(**options)

# Get tags by hostname
hostname='<YOUR_HOSTNAME>'
hosts = api.Hosts.search(q='hosts:')

for host in hosts['host_list']:
    if host['name'] == hostname:
        print(host['tags_by_source'])
require 'rubygems'
require 'dogapi'

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

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

host_name = 'test.host'
dog.host_tags(host_name)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

# pass a single hostname as an argument to search for the specified host
host=$1

# Find a host to add a tag to
host_name=$(curl -G "https://api.datadoghq.com/api/v1/search" \
    -d "api_key=${api_key}" \
    -d "application_key=${app_key}" \
	-d "q=hosts:$host" | cut -d'"' -f6)

curl "https://api.datadoghq.com/api/v1/tags/hosts/${host_name}?api_key=${api_key}&application_key=${app_key}"
Exemple de réponse
{
  'Datadog': [
    'host:dev-test',
    'environment:test'
  ],
  'Users': [
    'role:database'
  ]
}
["200", {
    "tags" => [
        "role:web",
        "environment:test"
    ]
}]
{
  "tags": [
    "role:database",
    "environment:test"
  ]
}

Tags

L’endpoint tag vous permet de taguer les hosts avec des mots-clés qui vous sont utiles, comme role:database. Toutes les métriques envoyées par un host se voient appliquer ses tags. Pour la récupération et l’application de tags à un host spécifique, utilisez le nom des hosts (yourhost.example.com) pour vous y référer.

Le composant de votre infrastructure responsable d’un tag est identifié par une source. Les sources valides sont : nagios, hudson, jenkins, users, feed, chef, puppet, git, bitbucket, fabric, capistrano, … Liste complète des valeurs d’attribut source.

En savoir plus sur les tags sur la page de la documentation dédiée.

Signature

POST /v1/tags/hosts/<HOSTNAME>

Exemple de requête
from datadog import initialize, api

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

initialize(**options)

# Add tags to a host
hostname='<YOUR_HOSTNAME>'
hosts = api.Hosts.search(q='hosts:')

for host in hosts['host_list']:
    if host['name'] == hostname:
        api.Tag.create(host['name'], tags=['<KEY>:<VALUE>'])
require 'rubygems'
require 'dogapi'

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

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

host_name = 'test.host'
dog.add_tags(host_name, ["role:database", "environment:production"])
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>

host=YourHostName
source=YourSource

# Find a host to add a tag to
host_name=$(curl -G "https://api.datadoghq.com/api/v1/search" \
    -d "api_key=${api_key}" \
    -d "application_key=${app_key}" \
    -d "q=hosts:$host" | cut -d'"' -f6)

curl  -X POST -H "Content-type: application/json" \
-d "{
      \"tags\" : [\"environment:production\", \"role:webserver\"]
}" \
"https://api.datadoghq.com/api/v1/tags/hosts/${host_name}?api_key=${api_key}&application_key=${app_key}&source=${source}"
Exemple de réponse
{
  'Datadog': [
    'host:dev-test',
    'environment:test'
  ],
  'Users': [
    'role:database'
  ]
}
["201", {
    "host" => "test.metric.host",
    "tags" => ["environment:production",
        "role:web",
        "role:database",
        "environment:test"
    ]
}]