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

Référence API

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

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

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

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

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.

There are many client libraries that wrap the Datadog API.

SIGNATURE:

  • If you are on the Datadog US site: https://api.datadoghq.com/api/
  • If you are on the Datadog EU site: https://api.datadoghq.eu/api/
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.

Authentication

All requests to Datadog’s API must be authenticated. Requests that write data require reporting access and require an API key. Requests that read data require full access and also require an application key.

Note: All Datadog API Clients are configured by default to consume Datadog US site APIs. If you are on the Datadog EU site, Set the environment variable DATADOG_HOST to https://api.datadoghq.eu or overide this value directly when creating your Client.

Manage your account’s API and application keys.

EXEMPLE :

from datadog import initialize, api

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

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

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

Réussites et erreurs

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

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

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

Codes de statut :

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

Exemple de réponse de type Error :

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

Exemple de réponse de type Warning :

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

Limites de débit

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

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

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

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

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

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

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

Troubleshooting

We do very minimal error checking on the API front-end, as we queue all data for asynchronous processing (the goal being to always, always accept your data in production situations and decouple the Datadog systems from yours).

Thus it is possible you could receive a 202 ‘success’ response but not see your data in Datadog. The cause of this is most likely:

  • Problems with the timestamp (either not in seconds or in the past, etc.)
  • Using the application key instead of API key
  • Events are succeeding, but because success events are low priority, they don’t show up in the event stream until it is switched to priority ‘all’

To check your timestamp is correct run:

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

This outputs the current system’s date, then makes a request to an API endpoint to grab the date on the Datadog end. If these are more than a few minutes apart, you may want to look at the time settings on your server.

There are also certain fields which are not mandatory for submission, but do require a valid input. For example, in submitting an event the priority field must be one of the four given options.

Any other text results in a 202 ‘success’ but no event showing up. Having an invalid source_type_name don’t prevent the event from showing up, but that field is dropped upon submission.

Note: Datadog API keys are case-sensitive. All your JSON attributes for POST endpoints should be in lowercase.

Checks de service

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

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

Envoyer le résultat d’un check

ARGUMENTS:

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

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

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

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

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

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

SIGNATURE:

POST /v1/check_run

EXEMPLE DE REQUÊTE:

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

options = {'api_key': '<DATADOG_API_KEY>',
           'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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'])
api_key="<DATADOG_API_KEY>"

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=${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.

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 Comment

Comments are essentially special forms of events that appear in the event stream. They can start a new discussion thread or optionally, reply in another thread.

ARGUMENTS:

  • message [required]: The comment text.

  • handle [optional, default = application key owner]: The handle of the user making the comment.

  • related_event_id [optional, default = None]: The id of another comment or event to reply to.

SIGNATURE:

POST /v1/comments

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

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

EXEMPLE DE RÉPONSE:

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

ARGUMENTS:

  • message [optional, default = original message]: The comment text.

  • handle [optional, default = Application key owner]: The handle of the user making the comment.

SIGNATURE:

PUT /v1/comments/<ID_COMMENTAIRE>

from datadog import initialize, api
from time import sleep

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
comment_id=<COMMENT_ID>

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

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

EXEMPLE DE RÉPONSE:

{
    'comment': {
        'handle': 'matt@example.com',
        'id': 2603645287324504065,
        'message': 'I think differently now.',
        'resource': '/api/v1/comments/2603645287324504065',
        'url': '/event/jump_to?event_id=2603645287324504065'
    }
}
["200", {
    "comment" => {
        "url" => "/event/jump_to?event_id=1382579089039712607",
        "resource" => "/api/v1/comments/1382579089039712607",
        "message" => "I've changed my mind again",
        "handle" => "mattp+org-carlotest141@datadoghq.com",
        "id" => 1382579089039712607
    }
}]
{
  "comment": {
    "handle": "mattp+org-carlotest141@datadoghq.com",
    "id": 1382557387240472966,
    "message": "Actually, I am changing my mind.",
    "resource": "/api/v1/comments/1382557387240472966",
    "url": "/event/jump_to?event_id=1382557387240472966"
  }
}
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:
    • definition [required]: Definition of the widget.
    • id [optional, default=auto-generated integer]: ID of the widget.
    • layout [required for widgets in dashboards with free layout_type only]. The structure of the layout follows this form:
      • x [required] The position of the widget on the x (horizontal) axis. Should be a non-negative integer.
      • y [required] The position of the widget on the y (vertical) axis. Should be a non-negative integer.
      • width [required] The width of the widget. Should be a non-negative integer.
      • height [required] The height of the widget. Should be a non-negative integer.
  • 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.
  • template_variable_presets [optional, default=None]: Array of template variables saved views. Saved views definitions follow this form:
    • name [required]: The name of the saved view.
    • template_variables [optional, default=None]: Array of template variables that don’t have their default value. Template variable definitions follow this form:
      • name [optional, default=None]: The name of the variable.
      • value [optional, default=None]: The value of the template variable within the saved view.

SIGNATURE:

POST /v1/dashboard

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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'
}]

saved_view = [{
    'name': 'Saved views for hostname 2',
    'template_variables': [{'name': 'host', 'value': '<HOSTNAME_2>'}]}
]

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,
                     template_variable_presets=saved_views)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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' => 'host',
    'prefix' => 'host',
    'default' => '<HOSTNAME_1>'
}]

saved_view = [{
  'name': 'Saved views for hostname 2',
  'template_variables': [{'name': 'host', 'value': '<HOSTNAME_2>'}]}
  ]

dog.create_board(title, widgets, layout_type, {
    'description' => description,
    'is_read_only' => is_read_only,
    'notify_list' => notify_list,
    'template_variables' => template_variables,
    'template_variable_presets' => saved_view
    })
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

{
   'notify_list':[
        'user@domain.com'
   ],
   'description':'A dashboard with memory info.',
   'template_variables':[
      {
         'default':'my-host',
         'prefix':'host',
         'name':'host1'
      }
   ],
   'is_read_only':True,
   'id':'qc9-tuk-9kv',
   'title':'Average Memory Free Shell',
   'url':'/dashboard/qc9-tuk-9kv/average-memory-free-shell',
   'created_at':'2019-02-05T01:20:56.323548+00:00',
   'modified_at':'2019-02-05T01:20:56.323548+00:00',
   'author_handle':'user@domain.com',
   'widgets':[
      {
         'definition':{
            'requests':[
               {
                  'q':'avg:system.mem.free{*}'
               }
            ],
            'type':'timeseries',
            'title':'Average Memory Free'
         },
         'id':2252428653625902
      }
   ],
   'layout_type':'ordered'
}
[
   "200",
   {
      "notify_list" => ["user@domain.com"],
      "description" => nil,
      "template_variables" => nil,
      "is_read_only" => true,
      "id" => "qc9-tuk-9kv",
      "title" => "Average Memory Free Shell",
      "url" => "/dashboard/qc9-tuk-9kv/average-memory-free-shell",
      "created_at" => "2019-02-05T01:35:46.388000+00:00",
      "modified_at" => "2019-02-05T01:35:46.388000+00:00",
      "author_handle" => "user@domain.com",
      "widgets" => [
         {
            "definition" => {
               "requests" => [
                   { "q" => "avg:system.mem.free{*}"}
               ],
               "type" => "timeseries",
               "title" => "Average Memory Free"
            },
            "id" => 2252428653625902
         }
      ],
      "layout_type" => "ordered"
   }
]
{
    "notify_list": [
        "user@domain.com"
    ],
    "description": "A dashboard with memory info.",
    "template_variables": [
        {
            "default": "my-host",
            "prefix": "host",
            "name": "host1"
        }
    ],
    "is_read_only": true,
    "id": "qc9-tuk-9kv",
    "title": "Average Memory Free Shell",
    "url": "/dashboard/qc9-tuk-9kv/average-memory-free-shell",
    "created_at": "2019-02-05T01:06:36.636295+00:00",
    "modified_at": "2019-02-05T01:06:36.636295+00:00",
    "author_handle": "user@domain.com",
    "widgets": [
        {
            "definition": {
                "requests": [
                    {
                        "q": "avg:system.mem.free{*}"
                    }
                ],
                "type": "timeseries",
                "title": "Average Memory Free"
            },
            "id": 2252428653625902
        }
    ],
    "layout_type": "ordered"
}
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:
    • definition [required]: Definition of the widget.
    • id [optional, default=auto-generated integer]: ID of the widget.
    • layout [required for widgets in dashboards with free layout_type only]. The structure of the layout follows this form:
      • x [required] The position of the widget on the x (horizontal) axis. Should be a non-negative integer.
      • y [required] The position of the widget on the y (vertical) axis. Should be a non-negative integer.
      • width [required] The width of the widget. Should be a non-negative integer.
      • height [required] The height of the widget. Should be a non-negative integer.
  • 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.
  • template_variable_presets [optional, default=None]: Array of template variables saved views. Saved views definitions follow this form:
    • name [required]: The name of the saved view.
    • template_variables [optional, default=None]: Array of template variables that don’t have their default value. Template variable definitions follow this form:
      • name [optional, default=None]: The name of the variable.
      • value [optional, default=None]: The value of the template variable within the saved view.

SIGNATURE:

PUT /v1/dashboard/<ID_DASHBOARD>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {'api_key': '<DATADOG_API_KEY>',
           'app_key': '<DATADOG_APPLICATION_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'
}]

saved_view = [{
    'name': 'Saved views for hostname 2',
    'template_variables': [{'name': 'host', 'value': '<HOSTNAME_2>'}]}
]

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,
                     template_variable_presets=saved_view)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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'
}]

saved_view = [{
  'name': 'Saved views for hostname 2',
  'template_variables': [{'name': 'host', 'value': '<HOSTNAME_2>'}]}
  ]

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,
    'template_variable_presets' => saved_view
    })
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
dashboard_id="<DASHBOARD_ID>"

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

EXEMPLE DE RÉPONSE:

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

Supprimer un dashboard

Supprimer un dashboard existant.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

DELETE /v1/dashboard/<ID_DASHBOARD>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

dashboard_id = '<DASHBOARD_ID>'

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dashboard_id = '<DASHBOARD_ID>'
dog.delete_board(dashboard_id)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
dashboard_id="<DASHBOARD_ID>"

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

EXEMPLE DE RÉPONSE:

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

Obtenir un dashboard

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/dashboard/<ID_DASHBOARD>

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

dashboard_id = '<DASHBOARD_ID>'

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dashboard_id = '<DASHBOARD_ID>'
dog.get_board(dashboard_id)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
dashboard_id="<DASHBOARD_ID>"

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

EXEMPLE DE RÉPONSE :

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

Obtenir tous les dashboards

Récupérer tous les dashboards.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/dashboard

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.get_all_boards()
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Listes de dashboards

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

Récupérer une liste de dashboards

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

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

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

result = dog.get_dashboard_list(4741)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

list_id=4741

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

EXEMPLE DE RÉPONSE:

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

Get all Dashboard Lists

Fetch all of your existing dashboard list definitions.

ARGUMENTS:

This endpoint takes no JSON arguments.

SIGNATURE:

GET /v1/dashboard/lists/manual

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

result = dog.get_all_dashboard_lists()
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Create a Dashboard List

Create an empty dashboard list.

ARGUMENTS:

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

SIGNATURE:

POST /v1/dashboard/lists/manual

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

name = 'My Dashboard List'

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

name = 'My Dashboard List'

result = dog.create_dashboard_list(name)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Update a Dashboard List

Update the name of a dashboard list

ARGUMENTS:

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

SIGNATURE :

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

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

list_id = 4741
name = 'My Updated Dashboard List'

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

list_id=4741

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

EXEMPLE DE RÉPONSE :

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

Delete a Dashboard List

Delete an existing dashboard list.

ARGUMENTS:

This endpoint takes no JSON arguments.

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

SIGNATURE:

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

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

result = dog.delete_dashboard_list(4741)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

list_id=4741

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

EXAMPLE RESPONSE:

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

Get Items of a Dashboard List

Fetch the dashboard list’s dashboard definitions.

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

ARGUMENTS:

This endpoint takes no JSON arguments.

SIGNATURE:

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

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

result = dog.v2.get_items_of_dashboard_list(4741)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

list_id=4741

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

EXEMPLE DE RÉPONSE:

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

Add dashboards to 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 add to 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.

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': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

list_id=4741

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

EXAMPLE RESPONSE:

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

Update Items of a Dashboard List

Update dashboards of an existing dashboard list.

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

ARGUMENTS:

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

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

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

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

SIGNATURE:

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

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

list_id=4741

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

EXAMPLE RESPONSE:

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

Delete Items from a Dashboard List

Delete dashboards from an existing dashboard list.

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

ARGUMENTS:

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

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

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

SIGNATURE :

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

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

list_id=4741

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

EXEMPLE DE RÉPONSE :

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

Downtimes

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

Planifier le downtime d’un monitor

ARGUMENTS:

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

SIGNATURE:

POST /v1/downtime

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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' => %w[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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

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

EXEMPLE DE RÉPONSE:


{
    'active': True,
    'canceled': None,
    'creator_id': 3658,
    'disabled': False,
    'end': 1445978817,
    'id': 169267576,
    'message': None,
    'monitor_id': None,
    'monitor_tags': ['*'],
    'parent_id': None,
    'recurrence': {
        'period': 1,
        'type': 'weeks',
        'until_date': 1448387217,
        'until_occurrences': None,
        'week_days': [
            'Mon',
            'Tue',
            'Wed',
            'Thu',
            'Fri'
        ]
    },
    'scope': ['env:staging'],
    'start': 1445968017,
    'updater_id': None
}
[
  '200', {
    'disabled' => false,
    'canceled' => nil,
    'active' => true,
    'message' => nil,
    'id' => 169_267_581,
    'end' => 1_445_978_819,
    'parent_id' => nil,
    'monitor_id' => nil,
    'monitor_tags' => ['*'],
    'recurrence' => {
      'until_date' => 1_448_387_219,
      'until_occurrences' => nil,
      'week_days' => %w[Mon Tue Wed Thu Fri],
      'type' => 'weeks',
      'period' => 1
    },
    'start' => 1_445_968_019,
    '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': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Update a downtime
downtime_id = 4336
dog.update_downtime(
  downtime_id,
  scope: 'env:testing',
  end: Time.now.to_i + 60_000,
  message: 'Doing some testing on staging.'
)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
downtime_id=4336

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

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

EXEMPLE DE RÉPONSE:


{
    'active': True,
    'disabled': False,
    'end': 1420447087,
    'id': 2910,
    'message': 'Doing some testing on staging.',
    'monitor_tags': ['*'],
    'scope': ['env:staging'],
    'start': 1420387032
}
[
  '200', {
    'end' => 1_418_303_372,
    'disabled' => false,
    'start' => 1_418_224_729,
    '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': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.cancel_downtime(1655)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
downtime_id=1656

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

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

EXEMPLE DE RÉPONSE:

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

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.

Cancel Monitor Downtimes By Scope

This endpoint is not supported in Datadog’s client libraries. To request this functionality, contact Datadog Support.

ARGUMENTS:

  • scope [required]: Cancel all downtimes with the given scope(s), e.g.:

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

SIGNATURE:

POST /v1/downtime/cancel/by_scope

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

# Cancel all downtimes with scope
api.Downtime.cancel_downtime_by_scope('env:testing')
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Cancel all downtimes with the given scope
dog.cancel_downtime_by_scope('env:testing')
#!/bin/bash

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

{"cancelled_ids": [123456789, 123456790]}
['200', { 'cancelled_ids' => [123_456_789, 123_456_790] }]
{
  "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': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Get a downtime object
downtime_id = 1625
dog.get_downtime(downtime_id)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

downtime_id=2473

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

EXEMPLE DE RÉPONSE:

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

Récupérer tous les downtimes de monitor

ARGUMENTS:

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

SIGNATURE:

GET /v1/downtime

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Get all downtimes
dog.get_all_downtimes
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

[
    {
        'active': False,
        'disabled': True,
        'end': 1412793983,
        'id': 1625,
        'monitor_tags': ['*'],
        'scope': ['env:staging'],
        'start': 1412792983
    },
    {
        'active': False,
        'disabled': True,
        'end': None,
        'id': 1626,
        'monitor_tags': ['*'],
        'scope': ['*'],
        'start': 1412792985
    }
]
[
  '200', [{
    'end' => 1_412_793_983,
    'disabled' => true,
    'start' => 1_412_792_983,
    'active' => false,
    'monitor_tags' => ['*'],
    'scope' => ['env:staging'],
    'id' => 1625
  }, {
    'end' => nil,
    'disabled' => true,
    'start' => 1_412_792_985,
    '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': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

# Initialize API Client
api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

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

EXEMPLE DE RÉPONSE:

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

Créer un embed

Crée un nouveau graphique intégrable.

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

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

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

ARGUMENTS:

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

SIGNATURE:

POST /v1/graph/embed

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import json

# Intialize request parameters including API/APP key
options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Get the HTML fragment for a previously generated embed with embed_id.

Returns: A JSON object with 8 elements:

  • embed_id: Token of the embed
  • graph_title: Tile of the graph
  • dash_name: Name of the dashboard the graph is on (null if none)
  • dash_url: URL of the dashboard the graph is on (null if none)
  • shared_by: ID of the use who shared the embed
  • html: HTML fragment for the embed (iframe)
  • revoked: Boolean flag for whther or not the embed is revoked

On failure, the return value is a JSON containing an error message {errors: [messages]}.

ARGUMENTS:

This endpoint takes no JSON arguments.

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': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

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

EXEMPLE DE RÉPONSE:

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

Activer un embed

Active un embed spécifié.

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

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

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

# Intialize request parameters including API/APP key
options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

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

EXEMPLE DE RÉPONSE:

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

Révoquer un embed

Révoque un embed spécifié.

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

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

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

# Intialize request parameters including API/APP key
options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"

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

EXEMPLE DE RÉPONSE :

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

Événements

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

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

Envoyer un événement

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

ARGUMENTS:

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

SIGNATURE:

POST /v1/events

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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.
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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=${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': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

event_id = '1375909614428331251'
dog.get_event(event_id)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

event_id=<EVENT_ID>

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

EXEMPLE DE RÉPONSE:


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

Interroger le flux d’événements

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

ARGUMENTS:

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

SIGNATURE:

GET /v1/events

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

# Note: this endpoint only accepts form-encoded requests.
currenttime=$(date +%s)
currenttime2=$(date --date='1 day ago' +%s)

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

EXEMPLE DE RÉPONSE:

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

Graphs

Take graph snapshots using the API.

Snapshot de graphique

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

ARGUMENTS:

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

SIGNATURE:

GET /v1/graph/snapshot

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

end_ts = Time.now().to_i
start_ts = end_ts - (60 * 60)
dog.graph_snapshot("system.load.1{*}", start_ts, end_ts)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

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

EXEMPLE DE RÉPONSE:

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

Hosts

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.

Search hosts

This endpoint allows searching for hosts by name, alias, or tag. Hosts live within the past 3 hours are included. Results are paginated with a max of 1000 results at a time.

Note: maintenance will not always be set

ARGUMENTS:

  • filter [optional, default=None]: Query string to filter search results, for instance: host:<HOSTNAME>.
  • sort_field [optional, default=cpu]: Sort hosts by the given field. Options: status, apps, cpu, iowait, load
  • sort_dir [optional, default=desc]: Direction of sort. Options: asc, desc
  • start [optional, default=0]: Host result to start search from.
  • count [optional, default=100]: Number of host results to return. Max 1000.
  • from [optional, default=now - 2 hours]: Number of seconds since UNIX epoch from which you want to search your hosts.

SIGNATURE:

GET /v1/hosts

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.search_hosts()
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

{
    "total_returned": 1,
    "host_list": [
        {
            "last_reported_time": 1577786283,
            "name": "<HOST_NAME>",
            "is_muted": false,
            "mute_timeout": null,
            "apps": ["docs"],
            "tags_by_source": {"Datadog": ["host:<HOST_NAME>"]},
            "up": true,
            "metrics": {"load": 0.5, "iowait": 3.2, "cpu": 99},
            "sources": [],
            "meta": {},
            "host_name": "<HOST_NAME>",
            "id": 1495952100,
            "aliases": ["<HOST_NAME>"]
        }
    ],
    "total_matching": 1
}
{
  "total_returned": 1,
  "host_list": [
    {
      "last_reported_time": 1577786283,
      "name": "<HOST_NAME>",
      "is_muted": false,
      "mute_timeout": null,
      "apps": ["docs"],
      "tags_by_source": {"Datadog": ["host:<HOST_NAME>"]},
      "up": true,
      "metrics": {"load": 0.5, "iowait": 3.2, "cpu": 99},
      "sources": [],
      "meta": {},
      "host_name": "<HOST_NAME>",
      "id": 1495952100,
      "aliases": ["<HOST_NAME>"]
    }
  ],
  "total_matching": 1
}
{
  "total_returned": 1,
  "host_list": [
    {
      "last_reported_time": 1577786283,
      "name": "<HOST_NAME>",
      "is_muted": false,
      "mute_timeout": null,
      "apps": ["docs"],
      "tags_by_source": {"Datadog": ["host:<HOST_NAME>"]},
      "up": true,
      "metrics": {"load": 0.5, "iowait": 3.2, "cpu": 99},
      "sources": [],
      "meta": {},
      "host_name": "<HOST_NAME>",
      "id": 1495952100,
      "aliases": ["<HOST_NAME>"]
    }
  ],
  "total_matching": 1
}

Nombre de hosts

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

ARGUMENTS:

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

SIGNATURE:

GET /v1/hosts/totals

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.host_totals()
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Désactiver un host

ARGUMENTS:

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

SIGNATURE:

POST /v1/host/<HOSTNAME>/mute

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:


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

Réactiver un host

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

POST /v1/host/<HOSTNAME>/unmute

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

hostname = "test.host"
dog.unmute_host(hostname)
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

{
    'action': 'Unmuted',
    'hostname': 'test.host'
}
["200", {
    "action" => "Unmuted",
    "hostname" => "test.host"
}]
{
  "action": "Unmuted",
  "hostname": "test.host"
}
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

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

Énumérer toutes les intégrations AWS

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/aws

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.AwsIntegration.list()
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.aws_integration_list
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

{u'accounts':
    [{
        u'errors': [],
        u'filter_tags': [u'filter:example'],
        u'host_tags': [u'hosttag:example'],
        u'account_specific_namespace_rules': {u'namespace1': False, u'namespace2': False},
        u'role_name': u'<DD_AWS_ROLE_NAME>',
        u'account_id': u'<DD_AWS_ACCOUNT_ID>'
    }]
}
{
  "accounts" => [{
    "errors" => [],
    "account_id" => "<AWS_ACCOUNT_ID>",
    "host_tags" => ["<KEY>:<VALUE>"],
    "account_specific_namespace_rules" => {},
    "role_name" => "DatadogAWSIntegrationRole",
    "filter_tags" => ["<KEY>:<VALUE>"]
  }]
}
{"accounts":
    [{
        "account_id": '112233445566',
        "role_name": "SomeDatadogRole",
        "filter_tags": ["filter123"],
        "host_tags": ["account":"demo"],
        "account_specific_namespace_rules": {"opsworks":false}
    }]
}
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.

  • role_name [required]:

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

  • access_key_id [required]:

    Your AWS access key ID. Only required if your AWS account is a GovCloud or China account.

  • secret_access_key [required]:

    Your AWS secret access key. Only required if your AWS account is a GovCloud or China account.

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

POST /v1/integration/aws

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.AwsIntegration.create(
    account_id="<AWS_ACCOUNT_ID>",
    host_tags=["tag:example"],
    filter_tags=["filter:example"],
    role_name="<AWS_ROLE_NAME>",
    account_specific_namespace_rules={'namespace1': True/False, 'namespace2': True/False}
)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

dog.aws_integration_create(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

{
    "external_id": "12345678910111213"
}
{
    "external_id"=> "12345678910111213"
}
{
    "external_id": "12345678910111213"
}

Mettre à jour une intégration AWS

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

PARAMÈTRES DE REQUÊTE [cURL uniquement] :

  • account_id [obligatoire] :

    L’ID de votre compte AWS existant sans les tirets. Il doit être transmis comme paramètre de requête. Uniquement requis pour la configuration de compte basée sur des rôles. Consultez l’intégration Datadog/AWS pour en savoir plus sur l’ID de votre compte AWS.

  • role_name [obligatoire] :

    Le nom de votre délégation de rôle Datadog existante. Il doit être transmis comme paramètre de requête. Uniquement requis pour la configuration de compte basée sur des rôles. Consultez les informations sur la configuration de l’intégration Datadog/AWS pour en savoir plus sur le nom de rôle de votre compte AWS.

  • access_key_id [obligatoire] :

    L’ID de votre clé d’accès AWS existante. Requis uniquement si votre compte AWS est un compte GovCloud ou Chine. Saisissez l’ID de la clé d’accès correspondante à modifier. L’ID doit être transmis comme paramètre de requête.

  • secret_access_key [obligatoire] :

    La clé d’accès de votre secret AWS existant. Requis uniquement si votre compte AWS est un compte GovCloud ou Chine. Saisissez l’ID de la clé d’accès correspondante. L’ID doit être transmis comme paramètre de requête.

ARGUMENTS SPÉCIFIQUES CURL :

  • account_id [facultatif, cURL uniquement] :

    L’ID de votre nouveau compte AWS sans les tirets. Il doit être transmis comme argument. Consultez l’intégration Datadog/AWS pour en savoir plus sur l’ID de votre compte AWS.

  • role_name [facultatif, cURL uniquement] :

    Le nom de votre nouvelle délégation de rôle Datadog. Il doit être transmis comme argument. Consultez les informations sur la configuration de l’intégration Datadog/AWS pour en savoir plus sur le nom de rôle de votre compte AWS.

  • access_key_id [facultatif, cURL uniquement] :

    L’ID de votre nouvelle clé d’accès AWS. Ne s’applique que si votre compte AWS est un compte GovCloud ou Chine.

  • secret_access_key [facultatif, cURL uniquement] :

    La clé d’accès de votre nouveau secret AWS. Ne s’applique que si votre compte AWS est un compte GovCloud ou Chine.

ARGUMENTS :

  • account_id [obligatoire, Python et Ruby] :

    L’ID de votre compte AWS existant sans les tirets. Il doit être transmis comme argument. Consultez l’intégration Datadog/AWS pour en savoir plus sur l’ID de votre compte AWS.

  • role_name [obligatoire, Python et Ruby] :

    Le nom de votre délégation de rôle Datadog existante. Il doit être transmis comme argument. Consultez les informations sur la configuration de l’intégration Datadog/AWS pour en savoir plus sur le nom de rôle de votre compte AWS.

  • access_key_id [obligatoire, Python et Ruby] :

    L’ID de votre clé d’accès AWS existante. Ne s’applique que si votre compte AWS est un compte GovCloud ou Chine.

  • secret_access_key [obligatoire, Python et Ruby] :

    La clé d’accès de votre secret AWS existant. Ne s’applique que si votre compte AWS est un compte GovCloud ou Chine.

  • new_account_id [facultatif, Python et Ruby] :

    L’ID de votre compte AWS existant sans les tirets. Il doit être transmis comme argument. Consultez l’intégration Datadog/AWS pour en savoir plus sur l’ID de votre compte AWS.

  • new_role_name [facultatif, Python et Ruby] :

    Le nom de votre nouvelle délégation de rôle Datadog. Il doit être transmis comme argument. Consultez les informations sur la configuration de l’intégration Datadog/AWS pour en savoir plus sur le nom de rôle de votre compte AWS.

  • new_access_key_id [facultatif, Python et Ruby] :

    L’ID de votre nouvelle clé d’accès AWS. Ne s’applique que si votre compte AWS est un compte GovCloud ou Chine.

  • new_secret_access_key [facultatif, Python et Ruby] :

    La clé d’accès de votre nouveau secret AWS. Ne s’applique que si votre compte AWS est un compte GovCloud ou Chine.

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

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

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

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

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

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

SIGNATURE:

PUT /v1/integration/aws

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

# For account_id/role_name
api.AwsIntegration.update(
    account_id="<EXISTING_AWS_ACCOUNT_ID>",
    role_name="<EXISTING_AWS_ROLE_NAME>",
    new_account_id="<NEW_AWS_ACCOUNT_ID>",
    new_role_name="<NEW_AWS_ROLE_NAME>",
    host_tags=["hosttag:example"],
    filter_tags=["filter:example"],
    account_specific_namespace_rules = {"namespace1":True/False, "namespace2":True/False}
)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

# Existing configuration goes here.
config = {
  "account_id": "<AWS_ACCOUNT_ID>",
  "role_name": 'DatadogAWSIntegrationRole'
}

# New configuration goes here.
new_config = {
  "account_id": '<NEW_AWS_ACCOUNT_ID>',
  "host_tags": ["<KEY>:<VALUE>"],
  "filter_tags": ["<KEY>:<VALUE>"],
  "role_name": '<NEW_AWS_ROLE_NAME>'
}

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

dog.aws_integration_update(config, new_config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

# Update an AWS Account in Datadog

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

EXEMPLE DE RÉPONSE:

{}
{}
{}

Supprimer une intégration AWS

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

ARGUMENTS:

SIGNATURE:

DELETE /v1/integration/aws

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

account_id = "<AWS_ACCOUNT_ID>"
role_name = "<AWS_ROLE_NAME>"

api.AwsIntegration.delete(account_id=account_id, role_name=role_name)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

config = {
  "account_id": '<AWS_ACCOUNT_ID>',
  "role_name": 'DatadogAWSIntegrationRole'
}

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

dog.aws_integration_delete(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

{}
{}
{}

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

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/integration/aws/available_namespace_rules

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.AwsIntegration.list_namespace_rules()
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.aws_integration_list_namespaces
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

[u'api_gateway', u'application_elb', u'appstream', u'appsync', u'athena', u'auto_scaling', u'billing', u'budgeting', u'cloudfront', u'cloudhsm', u'cloudsearch', u'cloudwatch_events', u'cloudwatch_logs', u'codebuild', u'cognito', u'collect_custom_metrics', u'connect', u'crawl_alarms', u'directconnect', u'dms', u'documentdb', u'dynamodb', u'ebs', u'ec2', u'ec2api', u'ec2spot', u'ecs', u'efs', u'elasticache', u'elasticbeanstalk', u'elastictranscoder', u'elb', u'emr', u'es', u'firehose', u'gamelift', u'glue', u'inspector', u'iot', u'kinesis', u'kinesis_analytics', u'kms', u'lambda', u'lex', u'mediaconnect', u'mediaconvert', u'mediapackage', u'mediatailor', u'ml', u'mq', u'msk', u'nat_gateway', u'neptune', u'network_elb', u'opsworks', u'polly', u'rds', u'redshift', u'rekognition', u'route53', u'route53resolver', u's3', u'sagemaker', u'ses', u'shield', u'sns', u'sqs', u'step_functions', u'storage_gateway', u'swf', u'translate', u'trusted_advisor', u'vpn', u'waf', u'workspaces', u'xray']
["api_gateway", "application_elb", "appstream", "appsync", "athena", "auto_scaling", "billing", "budgeting", "cloudfront", "cloudhsm", "cloudsearch", "cloudwatch_events", "cloudwatch_logs", "codebuild", "cognito", "collect_custom_metrics", "connect", "crawl_alarms", "directconnect", "dms", "documentdb", "dynamodb", "ebs", "ec2", "ec2api", "ec2spot", "ecs", "efs", "elasticache", "elasticbeanstalk", "elastictranscoder", "elb", "emr", "es", "firehose", "gamelift", "glue", "inspector", "iot", "kinesis", "kinesis_analytics", "kms", "lambda", "lex", "mediaconnect", "mediaconvert", "mediapackage", "mediatailor", "ml", "mq", "msk", "nat_gateway", "neptune", "network_elb", "opsworks", "polly", "rds", "redshift", "rekognition", "route53", "route53resolver", "s3", "sagemaker", "ses", "shield", "sns", "sqs", "step_functions", "storage_gateway", "swf", "translate", "trusted_advisor", "vpn", "waf", "workspaces", "xray"]
["api_gateway","application_elb","appsync","auto_scaling","billing","budgeting","cloudfront","cloudsearch","cloudwatch_events","cloudwatch_logs","codebuild","collect_custom_metrics","crawl_alarms","ddos_protection","directconnect","dms","documentdb","dynamodb","ebs","ec2","ec2api","ec2spot","ecs","efs","elasticache","elasticbeanstalk","elastictranscoder","elb","emr","es","firehose","gamelift","iot","kinesis","kinesis_analytics","kms","lambda","lex","ml","mq","nat_gateway","network_elb","opsworks","polly","rds","redshift","rekognition","route53","s3","sagemaker","ses","sns","sqs","state_machine","storage_gateway","swf","vpn","waf","workspaces","xray"]

Générer des ID externes

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

ARGUMENTS :

SIGNATURE :

PUT /v1/integration/aws/generate_new_external_id

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

account_id = "<AWS_ACCOUNT_ID>"
role_name = "<AWS_ROLE_NAME>"

api.AwsIntegration.generate_new_external_id(account_id=account_id, role_name=role_name)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

config = {
  "account_id": '<AWS_ACCOUNT_ID>',
  "role_name": 'DatadogAWSIntegrationRole'
}

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

dog.aws_integration_generate_external_id(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

{u'external_id': u'<NEW_EXTERNAL_ID>'}
{
    "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.

Integration AWS Logs

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

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

List all AWS Logs integrations

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

ARGUMENTS:

This endpoint takes no JSON arguments.

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

SIGNATURE:

GET /v1/integration/aws/logs

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.AwsLogsIntegration.list()
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.aws_logs_integrations_list
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

[{u'services': [u'list', u'of', u'enabled', u'services'], u'account_id': u'<AWS_ACCOUNT_ID>', u'lambdas': []}]
# Nothing here yet.
# Nothing here yet.
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 for which 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.

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

SIGNATURE:

GET /v1/integration/aws/logs/services

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.AwsLogsIntegration.list_log_services()
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.aws_logs_list_services
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

[{u'id': u's3', u'label': u'S3 Access Logs'}, {u'id': u'elb', u'label': u'Classic ELB Access Logs'}, {u'id': u'elbv2', u'label': u'Application ELB Access Logs'}, {u'id': u'cloudfront', u'label': u'CloudFront Access Logs'}, {u'id': u'redshift', u'label': u'Redshift Logs'}, {u'id': u'lambda', u'label': u'Lambda Cloudwatch Logs'}]
[{"id"=>"s3", "label"=>"S3 Access Logs"}, {"id"=>"elb", "label"=>"Classic ELB Access Logs"}, {"id"=>"elbv2", "label"=>"Application ELB Access Logs"}, {"id"=>"cloudfront", "label"=>"CloudFront Access Logs"}, {"id"=>"redshift", "label"=>"Redshift Logs"}, {"id"=>"lambda", "label"=>"Lambda Cloudwatch Logs"}]
[{"id":"s3","label":"S3 Access Logs"},{"id":"elb","label":"Classic ELB Access Logs"},{"id":"elbv2","label":"Application ELB Access Logs"},{"id":"cloudfront","label":"CloudFront Access Logs"},{"id":"redshift","label":"Redshift Logs"},{"id":"lambda","label":"Lambda Cloudwatch Logs"}]
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.

In order to enable the newly added Lambda, use the Enable an AWS service log collection endpoint.

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

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

account_id = "<AWS_ACCOUNT_ID>"
lambda_arn = "arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<LAMBDA_FUNCTION_NAME>"

api.AwsLogsIntegration.add_log_lambda_arn(account_id=account_id, lambda_arn=lambda_arn)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

config = {
    "account_id": '<AWS_ACCOUNT_ID>',
    "lambda_arn": 'arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<LAMBDA_FUNCTION_NAME>'
  }

dog.aws_logs_add_lambda(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

{}
{}
{}
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 Logs integration

Enable Automatic Log collection for your AWS services.

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:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

account_id = "<AWS_ACCOUNT_ID"
services = ["s3", "elb", "elbv2", "cloudfront", "redshift", "lambda"]

api.AwsLogsIntegration.save_services(account_id=account_id, services=services)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

config = {
    "account_id": '<AWS_ACCOUNT_ID>',
    "services": ['s3', 'elb', 'elbv2', 'cloudfront', 'redshift', 'lambda']
  }

dog.aws_logs_save_services(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

{}
{}
{}
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 Logs integration

Delete a Datadog-AWS logs 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.

SIGNATURE:

DELETE /v1/integration/aws/logs

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

account_id = "<AWS_ACCOUNT_ID>"
lambda_arn = "arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<LAMBDA_FUNCTION_NAME>"

api.AwsLogsIntegration.delete_config(account_id=account_id, lambda_arn=lambda_arn)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

config = {
    "account_id": '<AWS_ACCOUNT_ID>',
    "lambda_arn": 'arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<LAMBDA_FUNCTION_NAME>'
  }

dog.aws_logs_integration_delete(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

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

Check that AWS Lambda Function exists

Check function that verifies whether a given Lambda exists within a given AWS account. This endpoint can be polled continuously without blocking.

  • Returns a status of created when it’s checking if the Lambda exists in the account.
  • Returns a status of waiting while checking.
  • Returns a status of checked and ok if the Lambda exists.
  • Returns a status of error if the Lambda does not exist.

Note: You must have the given AWS account configured in the main AWS Integration tile for this to successfully verify.

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

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

account_id = "<AWS_ACCOUNT_ID>"
lambda_arn = "arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<FUNCTION_NAME>"

api.AwsLogsIntegration.check_lambda(account_id=account_id, lambda_arn=lambda_arn)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

config = {
    "account_id": '<AWS_ACCOUNT_ID>',
    "lambda_arn": 'arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<LAMBDA_FUNCTION_NAME>'
  }

dog.aws_logs_check_lambda(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

curl -X POST -H "Content-type: application/json" \
-d '{
        "account_id": "<AWS_ACCOUNT_ID>",
        "lambda_arn": "arn:aws:lambda:<REGION>:<AWS_ACCOUNT_ID>:function:<FUNCTION_NAME>"
    }' \
"https://api.datadoghq.com/api/v1/integration/aws/logs/check_async?api_key=${api_key}&application_key=${app_key}"

EXAMPLE RESPONSE:

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

Check permissions for Log Services

Test if permissions are present to add a log-forwarding triggers for the given services and AWS account. The input is the same as for Enable an AWS service log collection.

The call is done asynchronously, so can be repeatedly polled in a non-blocking fashion until the asynchronous request completes.

  • Returns a status of created when initialized.
  • Returns a status of waiting while checking.
  • Returns a status of checked and ok if the permissions exist.
  • Returns a status of error if the permissions do not exist.

Note: You must have the given AWS Lambda configured in the main AWS Integration tiles logs tab for this to successfully verify.

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_async

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

account_id = "<AWS_ACCOUNT_ID"
services = ["s3", "elb", "elbv2", "cloudfront", "redshift", "lambda"]

api.AwsLogsIntegration.check_services(account_id=account_id, services=services)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

config = {
    "account_id": '<AWS_ACCOUNT_ID>',
    "services": ['s3', 'elb', 'elbv2', 'cloudfront', 'redshift', 'lambda']
  }

dog.aws_logs_check_services(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

curl -X POST -H "Content-type: application/json" \
-d '{
        "account_id": "AWS_ACCOUNT_ID",
        "services": ["s3", "elb", "elbv2", "cloudfront", "redshift", "lambda"]
    }' \
"https://api.datadoghq.com/api/v1/integration/aws/logs/services_async?api_key=${api_key}&application_key=${app_key}"

EXAMPLE RESPONSE:

{u'status': u'<STATUS>'}
{"status"=>"<STATUS>"}
{"status":"<STATUS>"}
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

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

Énumérer toutes les intégrations Azure

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/azure

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.AzureIntegration.list()
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.azure_integration_list
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

[{u'tenant_name': u'<configured_tenant_name>', u'errors': [], u'client_id': u'<configured_client_id>', u'host_filters': u'current:filters'}]
{
  "tenant_name" => "<AZURE_TENANT_NAME>",
  "errors" => [],
  "host_filters" => "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>",
  "client_id" => "<AZURE_CLIENT_ID>"
}
OK

Créer une intégration Azure

Créer une intégration Datadog/Azure.

Remarque :

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

ARGUMENTS:

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

  • tenant_name [requis] :

    Votre ID Azure Active Directory.

  • client_id [requis] :

    Votre ID d’application Web Azure

  • client_secret [requis] :

    La clé de secret de votre application Web Azure.

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

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

SIGNATURE:

POST /v1/integration/azure

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.AzureIntegration.create(
    tenant_name="<AZURE_TENANT_NAME>",
    host_filters="<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>",
    client_id="<AZURE_CLIENT_ID>",
    client_secret="<AZURE_CLIENT_SECRET>"
)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

dog.azure_integration_create(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

{}
{}
OK

Supprimer une intégration Azure

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

ARGUMENTS:

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

  • tenant_name [requis] :

    Votre ID Azure Active Directory.

  • client_id [requis] :

    Votre ID d’application Web Azure

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

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

SIGNATURE :

DELETE /v1/integration/azure

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.AzureIntegration.delete(
    tenant_name="<AZURE_TENANT_NAME>",
    client_id="<AZURE_CLIENT_ID>"
)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

config = {
    "tenant_name": '<AZURE_TENANT_NAME>',
    "client_id": '<AZURE_CLIENT_ID>'
  }

dog.azure_integration_delete(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

{}
{}
OK

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

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

ARGUMENTS:

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

  • tenant_name [requis] :

    Votre ID Azure Active Directory.

  • client_id [requis] :

    Votre ID d’application Web Azure

  • client_secret [requis] :

    La clé de secret de votre application Web Azure.

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

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

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

SIGNATURE:

POST /v1/integration/azure/host_filters

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.AzureIntegration.update_host_filters(
    tenant_name="<AZURE_TENANT_NAME>",
    host_filters="new:filters",
    client_id="<AZURE_CLIENT_ID>"
)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

dog.azure_integration_update_host_filters(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

{}
{}
OK

Mettre à jour une intégration Azure

Mettre à jour l’intégration Datadog/Azure.

ARGUMENTS :

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

  • tenant_name [requis] :

    Votre ID Azure Active Directory existant.

  • new_tenant_name [facultatif] :

Votre nouvel ID Azure Active Directory.

  • client_id [requis] :

Votre ID d’application Web Azure existant.

  • new_client_id [facultatif] :

Votre nouvel ID d’application Web Azure.

  • client_secret [requis] :

    La clé de secret de votre application Web Azure.

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

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

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

SIGNATURE:

PUT /v1/integration/azure

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.AzureIntegration.update(
    tenant_name="<EXISTING_AZURE_TENANT_NAME>",
    new_tenant_name="<NEW_AZURE_TENANT_NAME>",
    host_filters="new:filters",
    client_id="<EXISTING_AZURE_CLIENT_ID>",
    new_client_id="<NEW_AZURE_CLIENT_ID>",
    client_secret="<EXISTING_CLIENT_SECRET>"
)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

config = {
  "tenant_name": "<AZURE_TENANT_NAME>",
  "new_tenant_name": "<NEW_AZURE_TENANT_NAME>",
  "host_filters": "new:filters",
  "client_id": "<AZURE_CLIENT_ID>",
  "new_client_id": "<NEW_AZURE_CLIENT_ID>",
  "client_secret": "<AZURE_CLIENT_SECRET>"
}

dog.azure_integration_update(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

curl -X PUT -H "Content-type: application/json" \
-d '{
        "tenant_name": "<AZURE_TENANT_NAME>",
        "new_tenant_name": "<NEW_AZURE_TENANT_NAME>",
        "client_id": "<AZURE_CLIENT_ID>",
        "new_client_id": "<NEW_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:

{}
{}
{}
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 GCP

Configure your Datadog-Google Cloud Platform (GCP) integration directly through the Datadog API. Read more about Datadog-Google Cloud Platform integration.

Énumérer toutes les intégrations GCP

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/gcp

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.GcpIntegration.list()
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.gcp_integration_list
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

[{u'automute': True||False, u'project_id': u'<GCP_PROJECT_ID>', u'client_email': u'<GCP_CLIENT_EMAIL>', u'errors': [], u'host_filters': u'current:filters'}]
{
  "automute" => false,
  "project_id" => "<GCP_PROJECT_ID>",
  "client_email" => "<CLIENT_EMAIL>",
  "errors" => [],
  "host_filters" => "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}
OK

Créer une intégration GCP

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

Remarque :

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

ARGUMENTS:

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

  • type [obligatoire] :

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

  • project_id [obligatoire] :

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

  • private_key_id [obligatoire] :

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

  • private_key [obligatoire] :

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

  • client_email [obligatoire] :

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

  • client_id [requis] :

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

  • auth_uri [obligatoire] :

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

  • token_uri [obligatoire] :

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

  • auth_provider_x509_cert_url [obligatoire] :

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

  • client_x509_cert_url [obligatoire] :

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

  • host_filters [facultatif] :

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

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

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

SIGNATURE :

POST /v1/integration/gcp

EXEMPLE DE REQUÊTE :

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.GcpIntegration.create(
    type="service_account",
    project_id="<GCP_PROJECT_ID>",
    private_key_id="<GCP_PRIVATE_KEY_ID>",
    private_key="<GCP_PRIVATE_KEY>",
    client_email="<GCP_CLIENT_EMAIL>",
    client_id="<GCP_CLIENT_ID>",
    auth_uri="<GCP_AUTH_URI>",
    token_uri="<GCP_TOKEN_URI>",
    auth_provider_x509_cert_url="<GCP_AUTH_PROVIDER_X509_CERT_URL>",
    client_x509_cert_url="<GCP_CLIENT_X509_CERT_URL>",
    host_filters="<KEY>:<VALUE>,<KEY>:<VALUE>"
)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

dog.gcp_integration_create(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

{}
{}
OK

Supprimer une intégration GCP

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

ARGUMENTS:

  • project_id [requis] :

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

  • client_email [obligatoire] :

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

SIGNATURE:

DELETE /v1/integration/gcp

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.GcpIntegration.delete(
    project_id="<GCP_PROJECT_ID>",
    client_email="<GCP_CLIENT_EMAIL>"
)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

config = {
    "project_id": "<GCP_PROJECT_ID>",
    "client_email": "<GCP_CLIENT_EMAIL>"
  }

dog.gcp_integration_delete(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

{}
{}
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 GCP integration

Update endpoint for GCP allowing you to enable or disable automute for a given Datadog-GCP integration, as well as modify host_filters.

ARGUMENTS:

  • project_id [required]:

    Your Google Cloud project ID found in your JSON service account key.

  • client_email [required]:

    Your email found in your JSON service account key.

  • automute [optional, default=false]:

    Silence monitors for expected GCE instance shutdowns.

  • host_filters [optional]:

    Limit the GCE 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:

PUT /v1/integration/gcp

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

api.GcpIntegration.update(
    project_id="<GCP_PROJECT_ID>",
    client_email="<GCP_CLIENT_EMAIL>",
    automute=True,
    host_filters="<NEW>:<FILTERS>"
)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

config= {
  "project_id": "<GCP_PROJECT_ID>",
  "client_email": "<GCP_CLIENT_EMAIL>",
  "automute": true,
  "host_filters": "<NEW>:<FILTERS>"
}

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

dog.gcp_integration_update(config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

{}
{}
OK

Intégration PagerDuty

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

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

Obtenir une intégration PagerDuty

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/pagerduty

EXEMPLE DE REQUÊTE:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.get_integration('pagerduty')
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Créer une intégration PagerDuty

Créez une intégration Datadog/PagerDuty.

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

ARGUMENTS:

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

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

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

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

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

  • api_token : Votre token d’API PagerDuty.

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

SIGNATURE:

PUT /v1/integration/pagerduty

EXAMPLE REQUEST:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

dog.create_integration('pagerduty', config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

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

Ajout de nouveaux services et calendriers

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

ARGUMENTS:

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

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

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

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

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

SIGNATURE:

POST /v1/integration/pagerduty

EXAMPLE REQUEST:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

dog.update_integration('pagerduty', config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

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

Supprimer une intégration PagerDuty

Supprimez l’intégration Datadog/PagerDuty.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

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

SIGNATURE:

DELETE /v1/integration/pagerduty

EXAMPLE REQUEST:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.delete_integration('pagerduty')
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

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

Intégration Slack

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

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

Obtenir l’intégration Slack

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/slack

EXEMPLE DE REQUÊTE:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.get_integration('slack')
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Créer une intégration Slack

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

Remarque :

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

ARGUMENTS:

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

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

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

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

SIGNATURE:

POST /v1/integration/slack

EXEMPLE DE REQUÊTE:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

dog.create_integration('slack', config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Add channels to Slack integration

Add channels to your Datadog-Slack integration.

ARGUMENTS:

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

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

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

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

SIGNATURE:

POST /v1/integration/slack

EXEMPLE DE REQUÊTE:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

dog.update_integration('slack', config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Supprimer une intégration Slack

Supprimez une intégration Datadog/Slack.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

DELETE /v1/integration/slack

EXEMPLE DE REQUÊTE:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.delete_integration('slack')
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Intégration Webhooks

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

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

Obtenir une intégration Webhooks

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

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/integration/webhooks

EXEMPLE DE REQUÊTE:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.get_integration('webhooks')
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Créer une intégration Webhooks

Créez une intégration Datadog/Webhooks.

Remarque :

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

ARGUMENTS :

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

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

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

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

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

SIGNATURE:

POST /v1/integration/webhooks

EXEMPLE DE REQUÊTE:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

dog.create_integration('webhooks', config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Mettre à jour une intégration Webhooks

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

ARGUMENTS :

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

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

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

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

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

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

SIGNATURE:

POST /v1/integration/webhooks

EXAMPLE REQUEST:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

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

dog.update_integration('webhooks', config)
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXAMPLE RESPONSE:

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

Supprimer une intégration Webhooks

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

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

DELETE /v1/integration/webhooks

EXEMPLE DE REQUÊTE:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.delete_integration('webhooks')
#!/bin/sh

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Gestion des clés

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

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

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

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

Obtenir toutes les clés d’API

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

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/api_key/

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

Obtenir une clé d’API

Obtenez une clé d’API spécifique.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/api_key/<CLÉ_API>

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

Créer une clé d’API

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

ARGUMENTS :

  • name [obligatoire] :

Le nom de votre clé d’API.

SIGNATURE :

POST /v1/api_key/<CLÉ_API>

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

Modifier une clé d’API

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

ARGUMENTS :

  • name [obligatoire] :

Le nom de votre clé d’API.

SIGNATURE :

PUT /v1/api_key/<CLÉ_API>

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

Supprimer une clé d’API

Supprimez une clé d’API donnée.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

DELETE /v1/api_key/<CLÉ_API>

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

Obtenir toutes les clés d’application

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

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/application_key/

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

Obtenir une clé d’application

Obtenez une clé d’application spécifique.

ARGUMENTS :

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/application_key/<CLÉ_APP>

EXEMPLE DE REQUÊTE:

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Créer une clé d’application

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

ARGUMENTS :

  • name [obligatoire] :

    Le nom de votre clé d’application.

SIGNATURE :

POST /v1/application_key/<CLÉ_APPLICATION>

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

Modifier une clé d’application

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

ARGUMENTS :

  • name [obligatoire] :

Le nom de votre clé d’application.

SIGNATURE :

PUT /v1/application_key/<CLÉ_APPLICATION>

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

Supprimer une clé d’application

Supprimez une clé d’application donnée.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

DELETE /v1/application_key/<CLÉ_APPLICATION>

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

Logs

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

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

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

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

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.

Send Logs over HTTP

ItemDescription
Protocolhttp: 80
https: 443
HostFor Datadog US: http-intake.logs.datadoghq.com
For Datadog EU: http-intake.logs.datadoghq.eu
PathFor API key passed in headers: /v1/input
For API key passed in path: /v1/input/<DATADOG_API_KEY>
HeadersHeader to pass the API key: DD-API-KEY
Query parametersQuery parameters available are the reserved log attribute. ?ddtags=<TAGS>&ddsource=<SOURCE>&service=<SERVICE>&hostname=<HOSTNAME>
MethodPOST
Content TypeAvailable content type are: text/plain, application/json, application/logplex-1

Note: If an API key is passed in both the headers and the path only the one in the headers is taken into account.

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
## API key passed in headers

curl -X POST https://http-intake.logs.datadoghq.com/v1/input \
     -H "Content-Type: text/plain" \
     -H "DD-API-KEY: <API_KEY>" \
     -d 'hello world'

## API key passed in path

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

## Log attributes can be passed as query parameters

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

## Multi Raw Messages

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

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

## Multi JSON Messages

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

## Simple Logplex Message

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

## Multi Logplex Messages

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

EXEMPLE DE RÉPONSE:

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

Récupérer la liste des logs

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

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

ARGUMENTS:

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

SIGNATURE:

POST api/v1/logs-queries/list

EXEMPLE DE REQUÊTE:

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

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.

Obtenir tous les index

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

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/logs/config/indexes/

EXEMPLE DE REQUÊTE:

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Obtenir un index

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

Cet endpoint renvoie un Index identifié par son nom.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

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

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

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

  • filter.query [required]: 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.

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Obtenir la séquence des index

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

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

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

GET /v1/logs/config/index-order

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE :

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

Mettre à jour la séquence des index

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

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

ARGUMENTS:

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

SIGNATURE:

PUT /v1/logs/config/index-order

EXEMPLE DE REQUÊTE:

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Pipelines de logs

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

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

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

Obtenir la séquence des pipelines

Obtenir la séquence actuelle de vos pipelines.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/logs/config/pipeline-order

EXEMPLE DE REQUÊTE:

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

Mettre à jour la séquence des pipelines

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

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

ARGUMENTS :

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

SIGNATURE:

PUT /v1/logs/config/pipeline-order

EXEMPLE DE REQUÊTE:

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Obtenir toutes les pipelines

Obtenez tous les pipelines de votre organisation.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/logs/config/pipelines

EXEMPLE DE REQUÊTE:

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Obtenir un pipeline

Obtenez un pipeline spécifique de votre organisation.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

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

EXEMPLE DE REQUÊTE:

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
pipeline_id=<PIPELINE_ID>

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

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "id": "<PIPELINE_ID>",
    "type": "pipeline",
    "name": "<PIPELINE_NAME>",
    "is_enabled": false,
    "is_read_only": true,
    "filter": {
        "query": "<PIPELINE_FILTER>"
    },
    "processors": [
        {
            "name": "<PROCESSOR_1_NAME>",
            "is_enabled": true,
            "source": "message",
            "grok": {
                "support_rules": "",
                "match_rules": "<MATCHED_RULES>"
            },
            "type": "grok-parser"
        },
        {
            "name": "Define timestamp as the official timestamp of the log",
            "is_enabled": true,
            "sources": [
                "timestamp"
            ],
            "type": "date-remapper"
        },
        {
            "name": "Define level as the official log status",
            "is_enabled": true,
            "sources": [
                "level"
            ],
            "type": "status-remapper"
        }
    ]
}

Créer un pipeline

Créez un pipeline dans votre organisation.

ARGUMENTS:

  • name [obligatoire] : Le nom de votre pipeline.

  • is_enabled [facultatif, défaut=False] : Valeur booléenne permettant d’activer votre pipeline.

  • filter.query [facultatif] : définit le filtre de votre pipeline. Seuls les logs correspondant aux critères du filtre sont traités par ce pipeline.

  • processors [facultatif] : un tableau ordonné de processeurs ou pipelines imbriqués. Consultez la documentation relative au processeur pour connaître le schémas spécifique à chaque processeur.

SIGNATURE:

POST /v1/logs/config/pipelines

EXEMPLE DE REQUÊTE:

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

curl -X POST \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
    "name": "<PIPELINE_NAME>",
    "is_enabled": true,
    "filter": {
        "query": "<PIPELINE_QUERY>"
    },
    "processors": [
        {
            "name": "Define date as the official timestamp of the log",
            "is_enabled": true,
            "sources": [
                "date"
            ],
            "type": "date-remapper"
        }
    ]
}' \
"https://api.datadoghq.com/api/v1/logs/config/pipelines"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "id": "7fKHTENgSkyGoJcCDbem-g",
    "type": "pipeline",
    "name": "<PIPELINE_NAME>",
    "is_enabled": true,
    "is_read_only": false,
    "filter": {
        "query": "<PIPELINE_QUERY>"
    },
    "processors": [
        {
            "name": "Define date as the official timestamp of the log",
            "is_enabled": true,
            "sources": [
                "date"
            ],
            "type": "date-remapper"
        }
    ]
}

Mettre à jour un pipeline

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

ARGUMENTS:

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

  • name [obligatoire] : Le nom de votre pipeline.

  • is_enabled [facultatif, défaut=False] : Valeur booléenne permettant d’activer votre pipeline.

  • filter.query [facultatif] : définit le filtre de votre pipeline. Seuls les logs correspondant aux critères du filtre sont traités par ce pipeline.

  • processors [facultatif] : un tableau séquentiel de processeurs ou pipelines imbriqués. Consultez la documentation relative au processeur pour obtenir le schéma spécifique à chaque processeur.

SIGNATURE:

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

EXEMPLE DE REQUÊTE:

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
pipeline_id=<PIPELINE_ID>

curl -X PUT \
-H 'Content-Type: application/json' \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
    "name": "<NEW_PIPELINE_NAME>",
    "is_enabled": true,
    "filter": {
        "query": "<NEW_PIPELINE_QUERY>"
    },
    "processors": [
        {
            "name": "Define date as the official timestamp of the log",
            "is_enabled": true,
            "sources": [
                "date"
            ],
            "type": "date-remapper"
        }
    ]
}' \
"https://api.datadoghq.com/api/v1/logs/config/pipelines/${pipeline_id}"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
    "id": "<PIPELINE_ID>",
    "type": "pipeline",
    "name": "<NEW_PIPELINE_NAME>",
    "is_enabled": true,
    "is_read_only": false,
    "filter": {
        "query": "<NEW_PIPELINE_QUERY>"
    },
    "processors": [
        {
            "name": "Define date as the official timestamp of the log",
            "is_enabled": true,
            "sources": [
                "date"
            ],
            "type": "date-remapper"
        }
    ]
}

Supprimer un pipeline

Supprimez un pipeline donné de votre organisation.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE :

DELETE /v1/logs/config/pipelines

EXEMPLE DE REQUÊTE :

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

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
pipeline_id=<PIPELINE_ID>

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

EXEMPLE DE RÉPONSE :

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{}
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.

Metrics

The metrics endpoint allows you to:

  • Post metrics data so it can be graphed on Datadog’s dashboards
  • Query metrics from any time period

Note that a graph can only contain a set number of points, and as the timeframe over which a metric is viewed increases, aggregation between points occurs to stay below that set number.

Datadog has a soft limit of 100 timeseries per host, where a timeseries is defined as a unique combination of metric name and tag.

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

Cet endpoint n’est pas pris en charge dans la bibliothèque client Ruby de Datadog. Pour demander cette fonctionnalité, contactez l’assistance Datadog.

Obtenez la liste des métriques de reporting actives depuis une date précise. Cet endpoint n’est pas disponible dans les bibliothèques Python et Ruby.

ARGUMENTS:

  • from [obligatoire] : secondes depuis l’epoch Unix
  • host [facultatif] : le hostname qui permet de filtrer la liste des métriques renvoyées. Si ce paramètre est défini, les métriques récupérées sont celles avec le tag de hostname correspondant.

SIGNATURE:

GET /v1/metrics

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

from_time=$((date +%s - 86400))

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d "from=${from_time}" \
-d "host=<HOSTNAME>" \
"https://api.datadoghq.com/api/v1/metrics"

EXEMPLE DE RÉPONSE:

{
    "metrics": [
        "system.load.1",
        "system.load.15",
        "system.load.5",
        "system.load.norm.1",
        "system.load.norm.15",
        "system.load.norm.5",
        "system.mem.buffered",
        "system.mem.cached",
        "system.mem.committed",
        "system.mem.free"
    ],
    "from": 1467815773
}
{
    "metrics": [
        "system.load.1",
        "system.load.15",
        "system.load.5",
        "system.load.norm.1",
        "system.load.norm.15",
        "system.load.norm.5",
        "system.mem.buffered",
        "system.mem.cached",
        "system.mem.committed",
        "system.mem.free"
    ],
    "from": 1467815773
}
{
  "metrics": [
    "system.load.1",
    "system.load.15",
    "system.load.5",
    "system.load.norm.1",
    "system.load.norm.15",
    "system.load.norm.5",
    "system.mem.buffered",
    "system.mem.cached",
    "system.mem.committed",
    "system.mem.free"
  ],
  "from": 1467815773
}
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.

Post timeseries points

The metrics end-point allows you to post time-series data that can be graphed on Datadog’s dashboards. The limit for compressed payloads is 3.2 megabytes (3200000), and 62 megabytes (62914560) for decompressed payloads.

Overhead:

If you’re submitting metrics directly to the Datadog API without using DogStatsD, expect:

  • 64 bits for the timestamp
  • 64 bits for the value
  • 20 bytes for the metric names
  • 50 bytes for the timeseries

The full payload is approximately ~ 100 bytes. However, with the DogStatsD API, compression is applied, which reduces the payload size.

ARGUMENTS:

  • series [required]: Pass a JSON array where each item in the array contains the following arguments:

    • metric [required]: The name of the timeseries
    • type [optional, default=gauge]: Type of your metric either: gauge, rate, or count
    • interval [optional, default=None]: If the type of the metric is rate or count, define the corresponding interval.
    • points [required]: A JSON array of points. Each point is of the form: [[POSIX_timestamp, numeric_value], ...] Note: The timestamp should be in seconds, current. The numeric value format should be a float value. Current is defined as not more than 10 minutes in the future or more than 1 hour in the past.
    • host [optional]: The name of the host that produced the metric.
    • tags [optional, default=None]: A list of tags associated with the metric.

SIGNATURE:

POST /v1/series

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<DATADOG_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 = '<DATADOG_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="<DATADOG_API_KEY>""

Interroger les points de séries temporelles

Cet endpoint vous permet d’interroger des métriques sur la période de votre choix. Utilisez la syntaxe de requête décrite dans la section De la requête au graphique.

Remarque : en Python, from est un mot réservé. À la place, l’API Python utilise les paramètres start et end dans l’appel de la fonction.

ARGUMENTS:

  • from [obligatoire, sauf en Python] : secondes depuis l’epoch unix.
  • to [obligatoire, sauf en Python] : secondes depuis l’epoch unix.
  • start [obligatoire en Python, défaut=None] : secondes depuis l’epoch unix.
  • end [obligatoire en Python, défaut=None] : secondes depuis l’epoch unix.
  • query [obligatoire] : la chaîne de requête.

SIGNATURE:

GET /v1/query

EXEMPLE DE REQUÊTE:

from datadog import initialize, api
import time

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
to_time=$(date +%s)
from_time=$(date --date='1 day ago' +%s)

curl -X GET \
    -H "DD-API-KEY: ${api_key}" \
    -H "DD-APPLICATION-KEY: ${app_key}" \
    "https://api.datadoghq.com/api/v1/query?&query=avg:system.cpu.user\{*\}by\{host\}&from=${from_time}&to=${to_time}"

EXEMPLE DE RÉPONSE:

{
    'status': 'ok',
    'res_type': 'time_series',
    'series': [{
        'end': 1430313599000,
        'metric': 'system.cpu.idle',
        'interval': 30,
        'start': 1430312070000,
        'length': 10,
        'aggr': None,
        'attributes': {},
        'pointlist': [
            [1430312070000.0, 75.08000183105469],
            [1430312100000.0, 99.33000183105469],
            [1430312130000.0, 99.83499908447266],
            [1430312160000.0, 100.0],
            [1430312190000.0, 99.66999816894531],
            [1430312220000.0, 100.0],
            [1430312250000.0, 99.83499908447266],
            [1430312280000.0, 99.66999816894531],
            [1430312310000.0, 99.83499908447266],
            [1430312340000.0, 99.66999816894531]
        ],
        'expression': 'system.cpu.idle{host:vagrant-ubuntu-trusty-64}',
        'scope': 'host:vagrant-ubuntu-trusty-64',
        'unit': None,
        'display_name': 'system.cpu.idle'
    }],
    'from_date': 1430309983000,
    'group_by': ['host'],
    'to_date': 1430313583000,
    'query': 'system.cpu.idle{*}by{host}',
    'message': u''
}
{
    'status' => 'ok',
    'res_type' => 'time_series',
    'series' => [{
        'end' => 1430313599000,
        'metric' => 'system.cpu.idle',
        'interval' => 30,
        'start' => 1430312070000,
        'length' => 10,
        'aggr' => nil,
        'attributes' => {},
        'pointlist' => [
            [1430312070000.0, 75.08000183105469],
            [1430312100000.0, 99.33000183105469],
            [1430312130000.0, 99.83499908447266],
            [1430312160000.0, 100.0],
            [1430312190000.0, 99.66999816894531],
            [1430312220000.0, 100.0],
            [1430312250000.0, 99.83499908447266],
            [1430312280000.0, 99.66999816894531],
            [1430312310000.0, 99.83499908447266],
            [1430312340000.0, 99.66999816894531]
        ],
        'expression' => 'system.cpu.idle{host:vagrant-ubuntu-trusty-64}',
        'scope' => 'host:vagrant-ubuntu-trusty-64',
        'unit' => nil,
        'display_name' => 'system.cpu.idle'
    }],
    'from_date' => 1430309983000,
    'group_by' => ['host'],
    'to_date' => 1430313583000,
    'query' => 'system.cpu.idle{*}by{host}',
    'message' => ''
}
{
  "status": "ok",
  "res_type": "time_series",
  "series": [
    {
      "metric": "system.cpu.idle",
      "attributes": {},
      "display_name": "system.cpu.idle",
      "unit": null,
      "pointlist": [
        [
          1430311800000,
          98.19375610351562
        ],
        [
          1430312400000,
          99.85856628417969
        ]
      ],
      "end": 1430312999000,
      "interval": 600,
      "start": 1430311800000,
      "length": 2,
      "aggr": null,
      "scope": "host:vagrant-ubuntu-trusty-64",
      "expression": "system.cpu.idle{host:vagrant-ubuntu-trusty-64}"
    }
  ],
  "from_date": 1430226140000,
  "group_by": [
    "host"
  ],
  "to_date": 1430312540000,
  "query": "system.cpu.idle{*}by{host}",
  "message": ""
}

Afficher les métadonnées d’une métrique

L’endpoint des métadonnées de métriques vous permet d’obtenir des métadonnées sur une métrique spécifique.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

GET /v1/metrics/<NOM_MÉTRIQUE>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

metric = 'system.cpu.idle'

api.Metadata.get(metric_name=metric)
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Get metadata on metric
result = dog.get_metadata('system.net.bytes_sent')

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

metric_name="system.net.bytes_sent"

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

EXEMPLE DE RÉPONSE:

{
    'description': 'Percent of time the CPU spent in an idle state.',
    'short_name': 'cpu idle',
    'integration': 'system',
    'statsd_interval': None,
    'per_unit': None,
    'type': 'gauge',
    'unit': 'percent'
}
{
 	"description" => "Percent of time the CPU spent in an idle state.",
 	"short_name" => "cpu idle",
 	"integration" => "system",
 	"statsd_interval" => nil,
 	"per_unit" => nil,
 	"type" => "gauge",
 	"unit" => "percent"
}
{
  "description": "My custom description",
  "short_name":"bytes sent",
  "integration": null,
  "statsd_interval": null,
  "per_unit": "second",
  "type": "gauge",
  "unit": "byte"
}

Modifier les métadonnées d’une métrique

L’endpoint des métadonnées de métriques vous permet de modifier les champs des métadonnées d’une métrique. En savoir plus sur les différents types pris en charge.

ARGUMENTS:

  • type [obligatoire] : type de la métrique, p. ex. gauge ou rate.
  • description [facultatif, défaut=None] : description de la chaîne de caractères de la métrique par défaut.
  • short_name [obligatoire] : nom raccourci de la métrique.
  • unit [facultatif, défaut=None] : unité primaire de la métrique, p. ex. byte ou operation.
  • per_unit [facultatif, défaut=None] : unité secondaire de la métrique, p. ex. seconde pour octets par seconde.
  • statsd_interval [facultatif, défaut=None] : le cas échéant, statds transmet l’intervalle en secondes pour la métrique.

SIGNATURE:

PUT /v1/metrics/<NOM_MÉTRIQUE>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

metric_name="system.net.bytes_sent"

curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "type": "gauge",
      "description": "my custom description",
      "short_name": "bytes sent",
      "unit": "byte",
      "per_unit": "second"
}' \
"https://api.datadoghq.com/api/v1/metrics/${metric_name}"

EXEMPLE DE RÉPONSE:

{
    'description': 'My custom description',
    'short_name': 'bytes sent',
    'integration': None,
    'statsd_interval': None,
    'per_unit': 'second',
    'type': 'gauge',
    'unit': 'byte'
}
{
 	"description" => "My custom description",
 	"short_name" => "bytes sent",
 	"integration" => nil,
 	"statsd_interval" => nil,
 	"per_unit" => "second",
 	"type" => "gauge",
 	"unit" => "byte"
}
{
  "description": "my custom description",
  "short_name": "bytes sent",
  "integration": null,
  "statsd_interval": null,
  "per_unit": "second",
  "type": "gauge",
  "unit": "byte"
}

Rechercher des métriques

Cet endpoint vous permet de rechercher des métriques parmi celles recueillies au cours des dernières 24 heures dans Datadog.

ARGUMENTS:

  • q [obligatoire] : la chaîne de requête utilisée pour la recherche de métriques. Doit commencer par metrics:

Remarque : le préfixe host: est également pris en charge pour rechercher des hostnames, mais il est maintenant obsolète. Utilisez l’endpoint de recherche de host à la place.

SIGNATURE:

GET /v1/search

EXEMPLE DE REQUÊTE:

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

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

dog.search("metrics:test")
api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d "api_key=${api_key}" \
-d "application_key=${app_key}" \
"https://api.datadoghq.com/api/v1/search?q=metrics:aws"

EXEMPLE DE RÉPONSE:


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

Monitors

Les monitors vous permettent de surveiller une métrique ou un check pertinent, en envoyant une notification à votre équipe lorsque certains seuils définis sont dépassés. Reportez-vous à la page Creating Monitors pour en savoir plus sur la création de monitors.

Créer un monitor

Si vous programmez la gestion et le déploiement des monitors, vous pouvez définir plus facilement le monitor dans l’IU Datadog et exporter son JSON valide.

ARGUMENTS:

  • type [obligatoire] : le type de monitor. Vous trouverez sous-dessous les différentes valeurs autorisées :
Type de monitorValeur de l’attribut du type
anomalyquery alert
apmquery alert
compositecomposite
customservice check
eventevent alert
forecastquery alert
hostservice check
integrationquery alert ou service check
live processprocess alert
logslog alert
metricmetric alert
networkservice check
outlierquery alert
processservice check
watchdogevent alert
  • query [obligatoire] : le paramètre query définit à quel moment le monitor se déclenche. La syntaxe de la requête dépend du type de monitor que vous créez :

    Requête d’alerte de métrique

    time_aggr(time_window):space_aggr:metric{tags} [by {key}] operator #

    • time_aggr : avg, sum, max, min, change ou pct_change.
    • time_window : last_#m (où # doit être remplacé par 5, 10, 15 ou 30), last_#h (où # doit être remplacé par 1, 2 ou 4) ou last_1d.
    • space_aggr : avg, sum, min ou max.
    • tags : un ou plusieurs tags (séparés par des virgules) ou *.
    • key : la ‘key’ de la syntaxe de tags key:value. Définit une alerte distincte pour chaque tag du groupe (alertes multiples).
    • operator : <, <=, >, >=, == ou !=.
    • # : un nombre entier ou un chiffre décimal utilisé pour définir le seuil.

    Si vous utilisez l’agrégateur temporel _change_ ou _pct_change_, utilisez plutôt change_aggr(time_aggr(time_window), timeshift):space_aggr:metric{tags} [by {key}] operator # avec :

    • change_aggr : change, pct_change.
    • time_aggr : avg, sum, max, min. En savoir plus.
    • time_window last_#m (1, 5, 10, 15 ou 30), last_#h (1, 2 ou 4) ou last_#d (1 ou 2)
    • timeshift : #m_ago (5, 10, 15 ou 30), #h_ago (1, 2 ou 4) ou 1d_ago.

    Utilisez ce paramètre pour créer un monitor outlier à l’aide de la requête suivante : avg(last_30m):outliers(avg:system.cpu.user{role:es-events-data} by {host}, 'dbscan', 7) > 0.

    Requête de check de service

    "check".over(tags).last(count).count_by_status()

    • check : nom du check, par exemple datadog.agent.up.
    • tags : un ou plusieurs tags entre guillemets (séparés par des virgules) ou « * ». Exemple : .over("env:prod", "role:db").
    • count doit être >= à votre seuil maximum (défini dans options). Par exemple, si vous souhaitez recevoir une notification à partir de 1 statut Critical, 3 statuts Ok et 2  statuts Warning, « count » doit prendre pour valeur 3. La valeur maximale est de 10.
    Requête d’alerte d’événement

    events('sources:nagios status:error,warning priority:normal tags: "string query"').rollup("count").last("1h")"

    • event : la chaîne de requête de l’événement.
    • string_query : requête en texte libre à comparer au titre et au texte de l’événement.
    • sources : sources des événements (séparées par des virgules). Liste complète des valeurs d’attributs source.
    • status : statuts des événements (séparés par des virgules). Valeurs autorisées : error, warn et info.
    • priority : priorités des événements (séparées par des virgules). Valeurs autorisées : low, normal ou all.
    • host : hosts de transmission d’événements (séparés par des virgules).
    • tags : tags d’événement (séparés par des virgules).
    • excluded_tags : tags des événements exclus (séparés par des virgules).
    • rollup : la méthode de cumulation des statistiques. count est actuellement la seule méthode prise en charge.
    • last : l’intervalle pour cumuler les totaux. Exemples : 60 s, 4 h. Unités de temps prises en charge : s, m, h et j.
    Requête d’alerte de processus

    processes(search).over(tags).rollup('count').last(timeframe) operator #

    • search : recherche en texte libre pour interroger les processus. Les processus correspondants correspondent aux résultats de la page Live Processes.
    • **tags** : un ou plusieurs tags (séparés par des virgules).
    • timeframe : l’intervalle pour cumuler les totaux. Exemples : 60 s, 4 h. Unités de temps prises en charge : s, m, h et j
    • operator : <, <=, >, >=, == ou !=.
    • # : un nombre entier ou un chiffre décimal utilisé pour définir le seuil.
    Requête de composite

    12345 && 67890, où 12345 et 67890 sont les identifiants de monitors non composites.

  • name [obligatoire, défaut=valeur dynamique, basée sur la requête] : le nom de l’alerte.

  • message [obligatoire, défaut=valeur dynamique, basée sur la requête] : un message à inclure avec les notifications pour ce monitor. Les notifications par e-mail peuvent être envoyées à des utilisateurs spécifiques en utilisant la même notation « @nomutilisateur » que les événements.

  • tags [facultatif, défaut=liste vide] : la liste de tags à associer à votre monitor. Lorsque vous obtenez tous les détails du monitor via l’API, utilisez l’argument monitor_tags pour filtrer les résultats avec ces tags. Ces valeurs ne peuvent être utilisées qu’avec l’API et ne sont ni visibles ni modifiables dans l’IU Datadog.

  • options [facultatif, défaut={}] : un dictionnaire d’options pour le monitor. Certaines options sont couramment utilisées pour tous les types, tandis que d’autres sont spécifiques à certains types de monitors.

    Options couramment utilisées
    • silenced : dictionnaire de contextes caractérisés par des timestamps ou la valeur None. Chaque contexte est désactivé jusqu’au timestamp POSIX. Les contextes peuvent également être définitivement désactivés avec la valeur None. Valeur par défaut : None. Exemples :

      • Pour désactiver complètement l’alerte : {'*': None}.
      • Pour désactiver role:db à court terme : {'role:db': 1412798116}.
    • new_host_delay : durée (en secondes) autorisée pour le démarrage d’un host et le lancement complet des applications avant le début de l’évaluation des résultats du monitor. Doit être un nombre entier non négatif. Valeur par défaut : 300.

    • notify_no_data : une valeur booléenne qui indique si ce monitor envoie une notification en absence de transmission de données. Valeur par défaut : false.

    • no_data_timeframe : le nombre de minutes avant qu’un monitor envoie une notification en l’absence de transmission de données. Ce paramètre est obligatoire lorsque notify_no_data​ est défini sur true. Il doit correspondre au moins au double de l’intervalle du monitor pour les alertes de métrique, ou à 2 minutes pour les checks de service. Valeur par défaut : le double de l’intervalle pour les alertes de métrique, 2 minutes pour les checks de service.

    • timeout_h : le nombre d’heures durant lesquelles le monitor ne transmet pas les données avant qu’il ne procède à une résolution automatique à partir d’un état déclenché. Valeur par défaut : None.

    • require_full_window : une valeur booléenne indiquant si ce monitor a besoin d’une période complète de données avant son évaluation. Nous vous recommandons fortement de définir ce paramètre sur False pour les métriques creuses, sans quoi certaines évaluations sont ignorées. Valeur par défaut : True pour les agrégations « on average », « at all times » et « in total ». Pour les autres cas, False.

    • renotify_interval : le nombre de minutes après la dernière notification avant qu’un monitor envoie à nouveau une notification sur le statut actuel. La notification est uniquement envoyée s’il le monitor n’est pas résolu. Valeur par défaut : None.

    • escalation_message : le message à inclure avec la nouvelle notification. Prend en charge la syntaxe ‘@username’ utilisée ailleurs. Non applicable si renotify_interval est défini sur None. Valeur par défaut : None.

    • notify_audit : une valeur booléenne qui indique si les utilisateurs tagués sont informés des modifications apportées à ce monitor. Valeur par défaut : False.

    • locked : une valeur booléenne qui indique si uniquement le créateur ou les administrateurs peuvent apporter des modifications. Valeur par défaut : False.

    • include_tags : une valeur booléenne qui indique si les notifications de ce monitor insèrent automatiquement les tags à l’origine du déclenchement dans le titre. Valeur par défaut : True. Exemples :

      • True : [Triggered on {host:h1}] Titre du monitor
      • False: [Triggered] Titre du monitor
    Options d’anomalie

    Ces options s’appliquent uniquement aux monitors d’anomalie et sont ignorées pour les autres types de monitors.

    • threshold_windows : un dictionnaire contenant recovery_window et trigger_window.

      • recovery_window désigne la durée pendant laquelle une métrique anormale doit afficher un comportement normal pour que l’alerte soit annulée.
      • trigger_window désigne la durée pendant laquelle une métrique doit afficher un comportement anormal pour que l’alerte soit déclenchée.

      Exemple : {'threshold_windows': {'recovery_window': 'last_15m', 'trigger_window': 'last_15m'}}

    Options d’alerte de métrique

    Ces options s’appliquent uniquement aux alertes de métrique.

    • thresholds : un dictionnaire de seuils par type de seuil. Il existe deux types de seuils pour les alertes de métrique : critical et warning. Critical est défini dans la requête, mais peut également être précisé dans cette option. Le seuil warning peut uniquement être spécifié à l’aide de l’option thresholds. Si vous souhaitez appliquer des seuils de rétablissement à votre monitor, utilisez les attributs critical_recovery et warning_recovery.

    Exemple : {'critical': 90, 'warning': 80, 'critical_recovery': 70, 'warning_recovery': 50}.

    • evaluation_delay : durée (en secondes) correspondant au délai avant l’évaluation (nombre entier non négatif). Par exemple, pour une valeur définie sur 300 (5 min), si l’intervalle est défini sur last_5m et s’il est 7 h, le monitor évalue les données de 6 h 50 à 6 h 55. Cette option s’avère très utile pour AWS CloudWatch et pour d’autres métriques renvoyées pour s’assurer que le monitor dispose toujours de données lors de l’évaluation.
    Options de check de service

    Ces options s’appliquent uniquement aux checks de service et sont ignorées pour les autres types de monitors.

    • thresholds : un dictionnaire de seuils par statut. Comme les checks de service peuvent avoir plusieurs seuils, nous ne les définissons pas directement dans la requête.

    Exemple : {'ok': 1, 'critical': 1, 'warning': 1}

    Erreurs et validation
    • Si une option de monitor non valide fait partie de la requête, la réponse sera :

    Error: 400 - ["Invalid monitor option:<option non valide>"]

SIGNATURE:

POST /v1/monitor

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "type": "metric alert",
      "query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high.",
      "tags": ["app:webserver", "frontend"],
      "options": {
      	"notify_no_data": true,
      	"no_data_timeframe": 20
      }
}' \
"https://api.datadoghq.com/api/v1/monitor"

EXEMPLE DE RÉPONSE:

{'creator': {'email': 'matt@example.com',
             'handle': 'matt@example.com',
             'id': 1896,
             'name': u'Matt'},
 'id': 2081,
 'message': 'We may need to add web hosts if this is consistently high.',
 'name': 'Bytes received on host0',
 'tags': ['app:webserver', 'frontend'],
 'options': {'no_data_timeframe': 20,
             'notify_audit': False,
             'notify_no_data': True,
             'silenced': {}},
 'org_id': 2,
 'overall_state': 'No Data',
 'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
 'type': 'metric alert',
 'multi': False,
 'created': '2015-12-18T16:34:14.014039+00:00',
 'modified': '2015-12-18T16:34:14.014039+00:00'
 }
['200', {
  'name' => 'Bytes received on host0',
  'org_id' => 1499,
  'tags' => ['app:webserver', 'frontend'],
  'options' => {
    'notify_no_data' => true,
    'no_data_timeframe' => 20,
    'notify_audit' => false,
    'silenced' => {}
  },
  'state' => {},
  'query' => 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
  'message' => 'We may need to add web hosts if this is consistently high.',
  'type' => 'metric alert',
  'id' => 92_089,
  '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"
}
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 monitor’s details

ARGUMENTS:

  • group_states [optional, default=None]: If this argument is set, the returned data includes additional information (if available) regarding the specified group states, including the last notification timestamp, last resolution timestamp and details about the last time the monitor was triggered. The argument should include a string list indicating what, if any, group states to include. Choose one or more from all, alert, warn, or no data. Example: ‘alert,warn’”
  • with_downtimes [optional, default = false]: If this argument is set to true, then the returned data includes all current downtimes for the monitor.

SIGNATURE:

GET /v1/monitor/<ID_MONITOR>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

# Get a monitor's details
api.Monitor.get(2081, group_states='all')
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Get a monitors's details
dog.get_monitor(91_879, group_states: 'all')
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
monitor_id=<YOUR_MONITOR_ID>

# Show a monitor
curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d "group_states=all" \
"https://api.datadoghq.com/api/v1/monitor/${monitor_id}"

EXEMPLE DE RÉPONSE:

{
    'id': 2081,
    'message': 'We may need to add web hosts if this is consistently high.',
    'name': 'Bytes received on host0',
    'options': {
        'no_data_timeframe': 20,
        'notify_audit': False,
        'notify_no_data': True,
        'silenced': {}
    },
    'org_id': 2,
    'overall_state': 'No Data',
    'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
    'type': 'metric alert',
    'multi': False,
    'created': '2015-12-18T16:34:14.014039+00:00',
    'modified': '2015-12-18T16:34:14.014039+00:00',
    "state": {
        "groups": {
            "host:host0": {
                "last_nodata_ts": null,
                "last_notified_ts": 1481909160,
                "last_resolved_ts": 1481908200,
                "last_triggered_ts": 1481909160,
                "name": "host:host0",
                "status": "Alert",
                "triggering_value": {
                    "from_ts": 1481909037,
                    "to_ts": 1481909097,
                    "value": 1000
                }
            }
        }
    }
}
['200', {
  'name' => 'Bytes received on host0',
  'org_id' => 1499,
  'options' => {
    'no_data_timeframe' => 20,
    'notify_no_data' => false,
    'notify_audit' => false,
    'silenced' => {}
  },
  'query' => 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
  'message' => 'We may need to add web hosts if this is consistently high.',
  'type' => 'metric alert',
  'id' => 91_879,
  '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' => 1_481_909_160,
        'last_resolved_ts' => 1_481_908_200,
        'last_triggered_ts' => 1_481_909_160,
        'name' => 'host:host0',
        'status' => 'Alert',
        'triggering_value' => {
          'from_ts' => 1_481_909_037,
          'to_ts' => 1_481_909_097,
          'value' => 1000
        }
      }
    }
  }
}]

{
  "id": 91879,
  "message": "We may need to add web hosts if this is consistently high.",
  "name": "Bytes received on host0",
  "options": {
    "no_data_timeframe": 20,
    "notify_audit": false,
    "notify_no_data": false,
    "silenced": {}
  },
  "org_id": 1499,
  "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
  "type": "metric alert",
  "multi": false,
  "created": "2015-12-18T16:34:14.014039+00:00",
  "modified": "2015-12-18T16:34:14.014039+00:00",
  "state": {
    "groups": {
      "host:host0": {
        "last_nodata_ts": null,
        "last_notified_ts": 1481909160,
        "last_resolved_ts": 1481908200,
        "last_triggered_ts": 1481909160,
        "name": "host:host0",
        "status": "Alert",
        "triggering_value": {
          "from_ts": 1481909037,
          "to_ts": 1481909097,
          "value": 1000
        }
      }
    }
  }
}

Modifier un monitor

ARGUMENTS:

  • query [obligatoire, facultatif lors de la modification] : La requête de la métrique pour laquelle les alertes sont envoyées.
  • name [obligatoire, facultatif lors de la modification] : Le nom du monitor.
  • message [facultatif, défaut=dynamique, en fonction de la requête] : Un message à inclure avec les notifications pour ce monitor. Les notifications par e-mail peuvent être envoyées à des utilisateurs spécifiques en utilisant la même notation « @nomutilisateur » que les événements.
  • options [facultatif, défaut={}] : Reportez-vous à la documentation relative à la création des monitors pour obtenir plus d’informations sur les options disponibles.
  • tags [facultatif, défaut=None] : La liste des tags à associer à votre monitor. Cela peut vous aider à catégoriser et à filtrer les monitors.

SIGNATURE:

PUT /v1/monitor/<ID_MONITOR>

EXEMPLE DE REQUÊTE:

from datadog import initialize,  api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_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 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Edit an existing monitor
dog.update_monitor(
  91_879,
  '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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
monitor_id=<YOUR_MONITOR_ID>

# Edit a monitor
curl -X PUT \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high."
}' \
"https://api.datadoghq.com/api/v1/monitor/${monitor_id}"

EXEMPLE DE RÉPONSE:


{
    'id': 2081,
    'message': 'We may need to add web hosts if this is consistently high.',
    'name': 'Bytes received on host0',
    'options': {'notify_audit': False, 'notify_no_data': False, 'silenced': {}},
    'org_id': 2,
    'overall_state': 'No Data',
    'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
    'type': 'metric alert',
    'multi': False,
    'created': '2015-12-18T16:34:14.014039+00:00',
    'modified': '2015-12-18T18:39:24.391207+00:00'
}
[
  '200', {
    'name' => 'We may need to add web hosts if this is consistently high.',
    'org_id' => 1499,
    'options' => {
      'notify_no_data' => false, 'notify_audit' => false, 'silenced' => {}
    },
    'state' => {},
    'query' => 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
    'message' => 'Bytes received on host0',
    'type' => 'metric alert',
    'id' => 91_879,
    '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"}
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

Check if a monitor can be deleted

ARGUMENTS:

  • monitor_ids The comma-separated list of monitor ids to check if they can be deleted.
Cette page n'est pas encore disponible en français, sa traduction est en cours.
Si vous avez des questions ou des retours sur notre projet de traduction actuel, n'hésitez pas à nous contacter.

SIGNATURE:

GET /v1/monitor/can_delete

EXAMPLE REQUEST:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

# Check if you can delete the given monitors.
api.Monitor.can_delete(monitor_ids=[56838, 771060, 1000376])
require 'rubygems'
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Check if you can delete the given monitors.
dog.can_delete_monitors([56838, 771060, 1000376])
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
monitor_id=<YOUR_MONITOR_ID>

# Check if you can delete the monitors
curl -X GET "https://api.datadoghq.com/api/v1/monitor/can_delete?api_key=${api_key}&application_key=${app_key}&monitor_ids=56838,771060,1000376"

EXAMPLE RESPONSE:

{
    "data": {"ok": [1000376]},
    "errors": {
        "771060": [
            "monitor 771060 is referenced in slos: 5bb564f7fcab59afbdc486a5cbebbec3, fd09b8be2879530191de98faa674c397, e3b3896f13f754b4b4f71ccf4c903ad2, a08c015e7060564ca31d89fb0298bacd, ee7c9f30f54b552f8c7287940d22987e, cf435f8454ba567491ad76214f6246cf, 21952a2b4e6e524981603c8b7bc78fff, 0745d5a4764a56b2859f07ec236647b5"
        ],
        "56838": [
            "monitor 56838 is referenced in slos: fb0b4534553653db8b955874f4c70813"
        ],
    },
}

Supprimer un monitor

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

DELETE /v1/monitor/<ID_MONITOR>

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

# Delete a monitor
api.Monitor.delete(2081)
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Delete a monitor
dog.delete_monitor(62_625)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_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' => 62_625
}]
{
  "deleted_monitor_id": 59409
}

Récupérer tous les détails d’un monitor

ARGUMENTS:

  • group_states [facultatif, défaut=None] : Si cet argument est défini, les données renvoyées comprennent d’éventuelles informations supplémentaires concernant les états des groupes spécifiés, notamment le timestamp de la dernière notification, le timestamp de la dernière résolution et les détails du dernier déclenchement du monitor. L’argument doit inclure une liste de chaînes de caractères indiquant, le cas échéant, les états de groupe à inclure. Choisissez une ou plusieurs des valeurs suivantes : « all », « alert », « warn » ou « no data ». Par exemple : « alert,warn ».
  • name [facultatif, défaut=None] : Une chaîne de caractères permettant de filtrer les monitors en fonction de leur nom.
  • tags [facultatif, défaut=None] : Une liste séparée par des virgules indiquant les tags, le cas échéant, à utiliser afin de filtrer la liste des monitors par contexte (par ex., host:host0). Pour obtenir plus d’informations, consultez le paramètre tags pour l’argument query approprié dans la section Créer un monitor ci-dessus.
  • monitor_tags [facultatif, défaut=None] : Une liste séparée par des virgules indiquant le service ou les tags personnalisés, le cas échéant, à utiliser afin de filtrer la liste des monitors. Les tags créés dans l’interface utilisateur de Datadog ont automatiquement la clé de service ajoutée en préfixe (par ex., service:my-app)
  • with_downtimes [facultatif, défaut=true] : Si cet argument est défini sur true, alors les données renvoyées comprennent les downtimes de chaque monitor.
  • page [facultatif, défaut=0] : La page où la pagination démarre. Si cet argument n’est pas spécifié, la requête renvoie tous les monitors sans pagination.
  • page_size [facultatif, défaut=100] : Le nombre de monitors à renvoyer par page. Si l’argument page n’est pas spécifié, tous les monitors sont renvoyés par défaut sans limite page_size. En revanche, si page est spécifié et page_size ne l’est pas, l’argument prend par défaut la valeur 100.

SIGNATURE:

GET /v1/monitor

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

# Get all monitor details
print(api.Monitor.get_all())
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

[
    {'creator': {
        'email': 'matt@example.com',
        'handle': 'matt@example.com',
        'id': 1896,
        'name': u'Matt'
    },
        'id': 2085,
        'message': u'',
        'name': '**system.net.bytes_rcvd** over **host:host0** was **> 100** on average during the **last 1h**.',
        'options': {'notify_audit': False, 'notify_no_data': False, 'silenced': {}},
        'org_id': 2,
        'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
        'type': 'metric alert',
        'multi': False,
        'created': '2015-12-18T16:34:14.014039+00:00',
        'modified': '2015-12-18T18:39:24.391207+00:00'},
    {'creator': {'email': 'matt@example.com',
                 'handle': 'matt@example.com',
                 'id': 1896,
                 'name': u'Matt'},
     'id': 2083,
     'message': 'We may need to add web hosts if this is consistently high.',
     'name': 'Bytes received on host0',
     'options': {'no_data_timeframe': 20,
                 'notify_audit': False,
                 'notify_no_data': True,
                 'silenced': {}},
     'org_id': 2,
     'overall_state': 'No Data',
     'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
     'type': 'metric alert',
     'multi': False,
     'created': '2015-12-18T16:34:14.014039+00:00',
     'modified': '2015-12-18T18:39:24.391207+00:00'
     }
]
[
  '200', [{
    'name' => 'Bytes received on host0',
    'org_id' => 1499,
    'options' => {
      'notify_no_data' => false, 'notify_audit' => false, 'silenced' => {}
    },
    'query' => 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
    'message' => 'We may need to add web hosts if this is consistently high.',
    'type' => 'metric alert',
    'multi' => false,
    'id' => 91_879,
    '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' => 91_875,
    'created' => '2015-12-18T16:34:14.014039+00:00',
    'modified' => '2015-12-18T16:34:14.014039+00:00'
  }]
]
[  
   {  
      "tags":[  

      ],
      "deleted":null,
      "query":"change(avg(last_5m),last_1m):avg:apache.net.hits{*} by {host} > 500",
      "message":"Host {{host.name}} with IP {{host.ip}} is under heavy load.",
      "matching_downtimes":[  

      ],
      "id":1111111,
      "multi":true,
      "name":"example title",
      "created":"2019-03-11T17:20:45.414125+00:00",
      "created_at":1552324845000,
      "creator":{  
         "id":1111111,
         "handle":"example@example.com",
         "name":"Jane Doe",
         "email":"example@example.com"
      },
      "org_id":1111111,
      "modified":"2019-03-11T17:20:45.414125+00:00",
      "overall_state_modified":"2019-03-19T12:55:48.320241+00:00",
      "overall_state":"No Data",
      "type":"query alert",
      "options":{  
         "notify_audit":false,
         "locked":false,
         "timeout_h":0,
         "silenced":{  

         },
         "include_tags":true,
         "no_data_timeframe":null,
         "require_full_window":true,
         "new_host_delay":300,
         "notify_no_data":false,
         "renotify_interval":0,
         "escalation_message":"",
         "thresholds":{  
            "critical":500,
            "warning":250
         }
      }
   },
   {  
      "tags":[  

      ],
      "deleted":null,
      "query":"avg(last_1m):outliers(avg:apache.net.hits{*} by {host}, 'DBSCAN', 3) > 0",
      "message":"@example@example.com",
      "matching_downtimes":[  

      ],
      "id":1111111,
      "multi":true,
      "name":"example title",
      "created":"2019-03-11T18:10:09.957865+00:00",
      "created_at":1552327809000,
      "creator":{  
         "id":111111,
         "handle":"example@example.com",
         "name":"Jane Doe",
         "email":"example@example.com"
      },
      "org_id":1111111,
      "modified":"2019-03-11T18:11:25.217705+00:00",
      "overall_state_modified":"2019-03-20T12:50:45.684420+00:00",
      "overall_state":"No Data",
      "type":"query alert",
      "options":{  
         "notify_audit":false,
         "locked":false,
         "timeout_h":0,
         "silenced":{  

         },
         "include_tags":true,
         "no_data_timeframe":null,
         "require_full_window":true,
         "new_host_delay":300,
         "notify_no_data":false,
         "renotify_interval":0,
         "escalation_message":""
      }
   }
]

Résoudre un monitor

ARGUMENTS:

  • resolve [obligatoire] : tableau de groupes à résoudre pour un monitor_id donné, p. ex. : {"monitor_id": "group_to_resolve"}

    Il est possible de spécifier plusieurs groupes par monitor, p. ex. : resolve: [{"monitor_id": "group_1"}, {"monitor_id": "group_2"}]

    Il est également possible de résoudre tous les groupes déclenchés à l’aide du pseudo-groupe ALL_GROUPS : resolve: [{"monitor_id": "ALL_GROUPS"}]

SIGNATURE:

POST https://api.datadoghq.com/monitor/bulk_resolve

EXEMPLE DE REQUÊTE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
"resolve": [
          {"<YOUR_MONITOR_ID>": "<YOUR_FIRST_GROUP>"},
          {"<YOUR_MONITOR_ID>": "<YOUR_SECOND_GROUP>"}
      ]
}' \
"https://app.datadoghq.com/monitor/bulk_resolve"

EXEMPLE DE RÉPONSE:

# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
[
  {
    "tags": [
      "*"
    ],
    "deleted": null,
    "query": "avg(last_1h):avg:system.cpu.user{role:cassandra} by {host} > 10",
    "message": "I'm a dummy test.",
    "id": 2610751,
    "multi": true,
    "name": "[Do not mind] This is a test",
    "created": "2017-08-09T14:30:38.584147+00:00",
    "created_at": 1502289038000,
    "org_id": 11287,
    "modified": "2017-08-09T14:36:48.176919+00:00",
    "overall_state_modified": "2017-08-11T12:21:05.949182+00:00",
    "overall_state": "Alert",
    "type": "metric alert",
    "options": {
      "notify_audit": false,
      "locked": false,
      "timeout_h": 0,
      "silenced": {},
      "include_tags": false,
      "no_data_timeframe": 10,
      "new_host_delay": 300,
      "require_full_window": false,
      "notify_no_data": false,
      "renotify_interval": 0,
      "escalation_message": "",
      "thresholds": {
        "critical": 10,
        "warning": 5
      }
    }
  }
]

Désactiver tous les monitors

En désactivant tous les monitors, ceux-ci n’enverront plus de notifications par e-mail et n’enverront plus d’événements dans le flux d’événements. Vous devrez consulter la page d’alertes pour vérifier les changements d’état.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

POST /v1/monitor/mute_all

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

# Mute all monitors
api.Monitor.mute_all()
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:


{
    'active': True,
    'disabled': False,
    'end': None,
    'id': 2728,
    'message': None,
    'scope': ['*'],
    'start': 1419440110
}
[
  '200', {
    'end' => nil,
    'disabled' => false,
    'start' => 1_412_805_855,
    'active' => true,
    'scope' => ['*'],
    'id' => 1647
  }
]
{
  "active": true,
  "disabled": false,
  "end": null,
  "id": 1648,
  "scope": [
    "*"
  ],
  "start": 1412805856
}

Réactiver tous les monitors

Annule la désactivation de tous les monitors. Renvoie une erreur si la fonction de désactivation de tous les monitors n’a pas été utilisée auparavant.

ARGUMENTS:

Cet endpoint ne prend aucun argument JSON.

SIGNATURE:

POST /v1/monitor/unmute_all

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

# Unmute all alerts
api.Monitor.unmute_all()
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

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

EXEMPLE DE RÉPONSE:

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

Désactiver un monitor

ARGUMENTS:

  • scope [facultatif, défaut=None] : Le contexte auquel appliquer la désactivation, p. ex. role:db. Par exemple, si votre alerte est groupée selon {host}, vous pouvez désactiver host:app1.
  • end [facultatif, défaut=None] : Timestamp POSIX correspondant à la fin de la désactivation.

SIGNATURE:

POST /v1/monitor/<ID_MONITOR>/mute

EXEMPLE DE REQUÊTE:


from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

# Mute a monitor
api.Monitor.mute(2088)
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Mute a monitor
dog.mute_monitor(62_628)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
monitor_id=<YOUR_MONITOR_ID>

# Mute a monitor
curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/monitor/${monitor_id}/mute"

EXEMPLE DE RÉPONSE:



{
    'id': 2088,
    'message': 'We may need to add web hosts if this is consistently high.',
    'name': 'Bytes received on host0',
    'options': {
        'notify_audit': False,
        'notify_no_data': False,
        'silenced': {
            '*': None
        }
    },
    'org_id': 2,
    'overall_state': 'No Data',
    'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
    'type': 'metric alert',
    'created': '2015-12-18T16:34:14.014039+00:00',
    'modified': '2015-12-18T18:39:24.391207+00:00'
}
[
  '200', {
    'name' => 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200',
    'org_id' => 1499,
    'options' => {
      'notify_no_data' => false,
      'notify_audit' => true,
      'timeout_h' => nil,
      'silenced' => {
        '*' => nil
      },
      'is_data_sparse' => false,
      'renotify_interval' => nil
    },
    'state' => {},
    'query' => 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200',
    'message' => '',
    'type' => 'metric alert',
    'id' => 62_628,
    'created' => '2015-12-18T16:34:14.014039+00:00',
    'modified' => '2015-12-18T18:39:24.391207+00:00'
  }
]
{
  "id": 62628,
  "message": "",
  "name": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
  "options": {
    "is_data_sparse": false,
    "notify_audit": true,
    "notify_no_data": false,
    "renotify_interval": null,
    "silenced": {
      "*": null
    },
    "timeout_h": null
  },
  "org_id": 1499,
  "query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200",
  "state": {},
  "type": "metric alert",
  "created": "2015-12-18T16:34:14.014039+00:00",
  "modified": "2015-12-18T18:39:24.391207+00:00"
}

Réactiver un monitor

ARGUMENTS:

  • scope [facultatif, défaut=None] : Le contexte auquel appliquer la désactivation. Par exemple, si votre alerte est groupée par {host}, vous pouvez désactiver ‘host:app1’.
  • all_scopes [facultatif, défaut=False] : Supprime les désactivations pour tous les contextes.

SIGNATURE:

POST /v1/monitor/<ID_MONITOR>/unmute

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    'api_key': '<DATADOG_API_KEY>',
    'app_key': '<DATADOG_APPLICATION_KEY>'
}

initialize(**options)

# Unmute all alerts
api.Monitor.unmute(2088)
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

# Unmute an alert
dog.unmute_monitor(62_628)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"
monitor_id=<YOUR_MONITOR_ID>

# Unmute a monitor
curl -X POST \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/monitor/${monitor_id}/unmute"

EXEMPLE DE RÉPONSE:



{
    'id': 2088,
    'message': 'We may need to add web hosts if this is consistently high.',
    'name': 'Bytes received on host0',
    'options': {
        'notify_audit': False,
        'notify_no_data': False,
        'silenced': {}
    },
    'org_id': 2,
    'overall_state': 'No Data',
    'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
    'type': 'metric alert',
    'created': '2015-12-18T16:34:14.014039+00:00',
    'modified': '2015-12-18T18:39:24.391207+00:00'
}
[
  '200', {
    'name' => 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200',
    'org_id' => 1499,
    'options' => {
      'notify_no_data' => false,
      'notify_audit' => true,
      'timeout_h' => nil,
      'silenced' => {},
      'is_data_sparse' => false,
      'renotify_interval' => nil
    },
    'state' => {},
    'query' => 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200',
    'message' => '',
    'type' => 'metric alert',
    'id' => 62_628,
    '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"
}
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.

Validate a monitor

Validates a monitor definition (see Create a monitor for details on constructing a monitor definition).

SIGNATURE:

POST /v1/monitor/validate

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
    "api_key": "<DATADOG_API_KEY>",
    "app_key": "<DATADOG_APPLICATION_KEY>"
}

initialize(**options)

monitor_type = "metric alert"
query = "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200"
monitor_options = {"thresholds": {"critical": 90.0}}

# Validate a monitor's definition
api.Monitor.validate(
    type=monitor_type,
    query=query,
    options=monitor_options,
)
require 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_KEY>'

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

type = 'metric alert'
query = 'THIS IS A BAD QUERY'
parameters = {
  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,
    thresholds: { critical: 90.0 }
  }
}

# Validate a monitor definition
dog.validate_monitor(type, query, parameters)
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account

api_key="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

curl -X POST \
-H "Content-type: application/json" \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
-d '{
      "type": "metric alert",
      "query": "THIS QUERY IS INVALID",
      "name": "Bytes received on host0",
      "message": "We may need to add web hosts if this is consistently high.",
      "tags": ["app:webserver", "frontend"],
      "options": {
      	"notify_no_data": true,
      	"no_data_timeframe": 20
      }
}' \
"https://api.datadoghq.com/api/v1/monitor/validate"

EXEMPLE DE RÉPONSE:

{"errors": ["Alert threshold (90.0) does not match that used in the query (200.0)."]}
['400', {
  'errors' => ["The value provided for parameter 'query' is invalid"]
}]
{
    "errors": [
        "The value provided for parameter 'query' is invalid"
    ]
}

Rechercher des monitors

Recherchez et filtrez les informations de vos monitors.

ARGUMENTS:

  • query [facultatif] :

    Après avoir saisi une requête de recherche dans votre page Manager Monitor, utilisez la valeur du paramètre de requête dans l’URL de la page comme valeur de ce paramètre. Consultez la page de documentation relative à la gestion des monitors pour en savoir plus.

    La requête peut contenir autant d’attributs de monitor que nécessaire (séparés par des espaces). Exemple : query="type:metric status:alert".

  • page [facultatif, défaut=0] :

    Page à partir de laquelle commencer la pagination.

  • per_page [facultatif, défaut=30] :

    Nombre de monitors à renvoyer par page.

  • sort [facultatif, défaut=null] :

    Une chaîne séparée par des virgules pour les champs pris en charge de l’ordre de tri (p. ex., name,asc) :

    • name
    • status
    • tags

SIGNATURE:

GET /v1/monitor/search

EXEMPLE DE REQUÊTE:

from datadog import initialize, api

options = {
	'api_key': '<DATADOG_API_KEY>',
	'app_key': '<DATADOG_APPLICATION_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 'dogapi'

api_key = '<DATADOG_API_KEY>'
app_key = '<DATADOG_APPLICATION_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="<DATADOG_API_KEY>"
app_key="<DATADOG_APPLICATION_KEY>"

query=<MANAGE_MONITOR_QUERY>
page=<PAGE_NUMBER>
per_page=<PER_PAGE>
sort=<SORT>

curl -X GET \
-H "DD-API-KEY: ${api_key}" \
-H "DD-APPLICATION-KEY: ${app_key}" \
"https://api.datadoghq.com/api/v1/monitor/search?query=${query}&page=${page}&per_page=${per_page}&sort=${sort}"

EXEMPLE DE RÉPONSE:

{ u'counts': 
    { u'muted': [{ u'count': 1, u'name': False}],
      u'status': [{ u'count': 1, u'name': u'Alert'}],
      u'tag': [ { u'count': 1, u'name': u'env:myenv'},
                { u'count': 1, u'name': u'service:sample'}],
      u'type': [{ u'count': 1, u'name': u'apm'}]},
  u'metadata': { u'page': 0,
                 u'page_count': 1,
                 u'per_page': 30,
                 u'total_count': 1},
  u'monitors': 
    [ { u'classification': u'apm',
        u'creator': { u'handle': u'jane@example.com',
                      u'id': 795042,
                      u'name': u'Jane'},
        u'id': 6797333,
        u'last_triggered_ts': 1540483133,
        u'metrics': [ u'trace.servlet.request.hits',
                      u'trace.servlet.request.errors'],
        u'name': u'Service sample has a high error rate on env:myenv',
        u'notifications': [ { u'handle': u'jane@example.com',
                              u'name': u'Jane'}],
        u'org_id': 11287,
        u'scopes': [u'env:myenv', u'service:sample'],
        u'status': u'Alert',
        u'tags': [u'env:myenv', u'service:sample'],
        u'type': u'query alert'}]}
['200',
 { 'counts' =>
   { 'status' => [{ 'count' => 1, 'name' => 'Alert' }],
     'muted' => [{ 'count' => 1, 'name' => false }],
     'tag' =>
     [{ 'count' => 1, 'name' => 'env:myenv' },
      { 'count' => 1, 'name' => 'service:sample' }],
     'type' => [{ 'count' => 1, 'name' => 'apm' }] },
   'monitors' =>
   [{ 'status' => 'Alert',
      'scopes' => ['env:myenv', 'service:sample'],
      'classification' => 'apm',
      'creator' =>
      { 'handle' => 'jane@example.com',
        'id' => 795_042,
        'name' => 'Jane' },
      'metrics' => ['trace.servlet.request.hits', 'trace.servlet.request.errors'],
      'notifications' =>
      [{ 'handle' => 'jane@example.com', 'name' => 'Jane' }],
      'last_triggered_ts' => 1_540_483_133,
      'id' => 6_797_333,
      'name' => 'Service sample has a high error rate on env:myenv',
      'tags' => ['env:myenv', 'service:sample'],
      'org_id' => 11_287,
      'type' => 'query alert' }],
   'metadata' => { 'total_count' => 1, 'page_count' => 1, 'page' => 0, 'per_page' => 30 } }]
{
  "counts": {
    "status": [
      {
        "count": 4,
        "name": "No Data"
      },
      {
        "count": 2,