This section details Datadogs HTTP API. It makes it easy to get data in and out of Datadog.
The Datadog API uses resource-oriented URLs, uses status codes to indicate the success or failure of requests and returns JSON from all requests. Let’s dive in and see how it works.
Note: cURL code examples assume usage of BASH and GNU coreutils. On macOS you can install coreutils via the Homebrew package manager: brew install coreutils
There are many client libraries that wrap the Datadog API.
https://api.datadoghq.com/api/
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.
from datadog import initialize, api
options = {'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'}
initialize(**options)
require 'rubygems'
require 'dogapi'
dog = Dogapi::Client.new('<YOUR_API_KEY>', '<YOUR_APP_KEY>')
curl "https://api.datadoghq.com/api/v1/validate?api_key=<YOUR_API_KEY>"
The Datadog API uses HTTP status codes to indicate the success or failure of a request.
An error indicates that the service did not successfully handle your request. In addition to the status code, the response may contain a JSON object with an errors array containing more detailed error messages. Note: When using libraries, some errors may throw exceptions rather than return JSON objects.
If the service is able to handle your request, but some issues are present (e.g. using a deprecated API or API version), the HTTP status code indicates success and the response body contains the expected result with the addition of a warnings array containing detailed warning messages.
200 200201 Created202 accepted204 No Content301 301304 Not Modified401 401403 Forbidden 404404 Not Found409 409413 Request payload too large422 Unprocessable500 Server ErrorAccepted 204Conflict 422Entity 500Moved Permanently 304OK 201Unauthorized 403{ 'errors': [
'Something bad happened to the server.',
'Your query made the server very sad.'
]
}
{ 'some_thing': ...,
'some_other_thing': ...,
'warnings': [
'This is a deprecated API.'
]
}
Some of the API endpoints are rate limited. Once you exceed a certain number of requests in a certain time period we return an error.
For rate limited API endpoints we return headers so you can know how close you are to your limit. If you exceed your limit, review these headers to determine when you are able to try again.
Rate limits can be increased from defaults by contacting the Datadog support team.
Regarding API rate limit policy:
100 per hour per organization.1000 per aggregate per day per organization. An aggregate is a group of similar events.300 per hour per organization. This can be extended on demand.60 per hour per organization. This can be extended on demand.X-RateLimit-Limit number of requests allowed in a time periodX-RateLimit-Period length of time in seconds for resets (calendar aligned)X-RateLimit-Remaining number of allowed requests left in current time periodX-RateLimit-Reset time in seconds until next resetWe 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:
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.
The service check endpoint allows you to post check statuses for use with monitors.
Service check messages are limited to 500 characters. If a check is posted with a message containing more than 500 characters, only the 500 first characters are displayed.
check [required]:
The text for the message
host_name [required]:
The name of the host submitting the check
status [optional]:
An integer for the status of the check:
timestamp [optional]:
POSIX timestamp of the event.
message [optional]:
A description of why this status occurred
tags [optional]:
A list of key:val tags for this check
POST https://api.datadoghq.com/api/v1/check_run
from datadog import initialize, api
from datadog.api.constants import CheckStatus
options = {'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'}
initialize(**options)
check = 'app.ok'
host = 'app1'
status = CheckStatus.OK # equals 0
tags = ['env:test']
api.ServiceCheck.check(check=check, host_name=host, status=status, message='Response: 200 OK', tags=tags)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# submitting a check doesn't require an app_key
dog = Dogapi::Client.new(api_key)
dog.service_check('app.is_ok', 'app1', 0, :message => 'Response: 200 OK', :tags => ['env:test'])
currenttime=$(date +%s)
curl -X POST -H "Content-type: application/json" \
-d "{
\"check\": \"app.is_ok\",
\"host_name\": \"app1\",
\"timestamp\": $currenttime,
\"status\": 0,
\"tags\": [\"env:test\"]
}" \
'https://api.datadoghq.com/api/v1/check_run?api_key=<YOUR_API_KEY>'
{
'status': 'ok'
}
["202", {
"status" => "ok"
}]
{
"status": "ok"
}
Comments are how discussion happens on Datadog. Create, edit, delete and reply to comments.
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.
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.
POST https://api.datadoghq.com/api/v1/comments
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Start a new discussion.
# Include a handle like this
api.Comment.create(
handle='matt@example.com',
message='Should we use COBOL or Fortran!'
)
# Or set it to None
# and the handle defaults
# to the owner of the application key
api.Comment.create(message='Should we use COBOL or Fortran?')
# Reply to a discussion.
api.Comment.create(
handle='joe@example.com',
message='Smalltalk?',
related_event_id=1234
)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Make a comment.
dog.comment("I have something to say.")api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -X POST -H "Content-type: application/json" \
-d '{
"message" : "There is a problem with the database."
}' \
"https://api.datadoghq.com/api/v1/comments?api_key=${api_key}&application_key=${app_key}"{
'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"
}
}message [optional, default = original message]:
The comment text.
handle [optional, default = Application key owner]:
The handle of the user making the comment.
PUT https://api.datadoghq.com/api/v1/comments/<COMMENT_ID>
from datadog import initialize, api
from time import sleep
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Edit a comment.
newcomment = api.Comment.create(
message='Should we use COBOL or Fortran or Widgets?'
)
sleep(1)
api.Comment.update(
newcomment['comment']['id'],
message='I think differently now!'
)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
comment_id = "1382579089039712607"
dog = Dogapi::Client.new(api_key, app_key)
# Update a comment.
dog.update_comment(comment_id, :message => "I've changed my mind again")api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
comment_id=1382557387240472966
# Create a comment to edit. Use jq (http://stedolan.github.io/jq/download/) to get the comment id.
comment_id=$(curl -X POST -H "Content-type: application/json" -d '{"message" : "This comment was submitted and will be edited by the api."}' "https://api.datadoghq.com/api/v1/comments?api_key=${api_key}&application_key=${app_key}" | jq -r '.comment.resource|ltrimstr("/api/v1/comments/")')
curl -X PUT -H "Content-type: application/json" \
-d '{
"message" : "Actually, I am changing my mind."
}' \
"https://api.datadoghq.com/api/v1/comments/${comment_id}?api_key=${api_key}&application_key=${app_key}"
{
'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"
}
}This end point takes no JSON arguments.
DELETE https://api.datadoghq.com/api/v1/comments/<COMMENT_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
newcomment = api.Comment.create(message='Should we use COBOL or Fortran?')
api.Comment.delete(newcomment['comment']['id'])
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.delete_comment("1378619807595725030")api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
# comment_id=1382559936236196216
# Create a comment to delete. Use jq (http://stedolan.github.io/jq/download/) to get the comment id.
comment_id=$(curl -X POST -H "Content-type: application/json" \
-d '{"message" : "This comment was submitted and will be deleted by the api."}' \
"https://api.datadoghq.com/api/v1/comments?api_key=${api_key}&application_key=${app_key}" | jq -r '.comment.resource|ltrimstr("/api/v1/comments/")')
sleep 1
curl -X DELETE "https://api.datadoghq.com/api/v1/comments/${comment_id}?api_key=${api_key}&application_key=${app_key}"This end point does not return JSON on successful requests.
This endpoint allows you to programmatically create, update, delete, and query dashboards.
title [required]:widgets [required]:definition [required]:id [optional, default=auto-generated integer]:layout_type [required]:ordered (previous timeboard) or free (previous screenboard layout)description [optional, default=None]:is_read_only [optional, default=False]:True, only the author and admins can make changes to it.notify_list [optional, default=None]:template_variables [optional, default=None]:name [required]:default [optional, default=None]:prefix [optional, default=None]:POST https://api.datadoghq.com/api/v1/dashboard
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
title = 'Average Memory Free Shell'
widgets = [{
'definition': {
'type': 'timeseries',
'requests': [
{'q': 'avg:system.mem.free{*}'}
],
'title': 'Average Memory Free'
}
}]
layout_type = 'ordered'
description = 'A dashboard with memory info.'
is_read_only = True
notify_list = ['user@domain.com']
template_variables = [{
'name': 'host1',
'prefix': 'host',
'default': 'my-host'
}]
api.Dashboard.create(title=title,
widgets=widgets,
layout_type=layout_type,
description=description,
is_read_only=is_read_only,
notify_list=notify_list,
template_variables=template_variables)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Create a dashboard.
title = 'Average Memory Free Shell'
widgets = [{
'definition': {
'type' => 'timeseries',
'requests' => [
{'q' => 'avg:system.mem.free{*}'}
],
'title' => 'Average Memory Free'
}
}]
layout_type = 'ordered'
description = 'A dashboard with memory info.'
is_read_only = true
notify_list = ['user@domain.com']
template_variables = [{
'name' => 'host1',
'prefix' => 'host',
'default' => 'my-host'
}]
dog.create_board(title, widgets, layout_type, {
'description' => description,
'is_read_only' => is_read_only,
'notify_list' => notify_list,
'template_variables' => template_variables
})
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -X POST -H "Content-type: application/json" \
-d '{
"title" : "Average Memory Free Shell",
"widgets" : [{
"definition": {
"type": "timeseries",
"requests": [
{"q": "avg:system.mem.free{*}"}
],
"title": "Average Memory Free"
}
}],
"layout_type": "ordered",
"description" : "A dashboard with memory info.",
"is_read_only": true,
"notify_list": ["user@domain.com"],
"template_variables": [{
"name": "host1",
"prefix": "host",
"default": "my-host"
}]
}' \
"https://api.datadoghq.com/api/v1/dashboard?api_key=${api_key}&application_key=${app_key}"
{
'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"
}
title [required]:widgets [required]:definition [required]:id [optional, default=auto-generated integer]:layout_type [required]:ordered (previous timeboard) or free (previous screenboard layout)description [optional, default=None]:is_read_only [optional, default=False]:True, only the author and admins can make changes to it.notify_list [optional, default=None]:template_variables [optional, default=None]:name [required]:default [optional, default=None]:prefix [optional, default=None]:PUT https://api.datadoghq.com/api/v1/dashboard/<DASHBOARD_ID>
from datadog import initialize, api
options = {'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'}
initialize(**options)
dashboard_id = '<DASHBOARD_ID>'
title = 'Sum of Memory Free'
widgets = [{
'definition': {
'type': 'timeseries',
'requests': [
{'q': 'sum:system.mem.free{*}'}
],
'title': 'Sum Memory Free Shell'
}
}]
layout_type = 'ordered'
description = 'An updated dashboard with memory info.'
is_read_only = True
notify_list = ['user@domain.com']
template_variables = [{
'name': 'host1',
'prefix': 'host',
'default': 'my-host'
}]
api.Dashboard.update(dashboard_id,
title=title,
widgets=widgets,
layout_type=layout_type,
description=description,
is_read_only=is_read_only,
notify_list=notify_list,
template_variables=template_variables)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dashboard_id = '<DASHBOARD_ID>'
title = 'Sum of Memory Free'
widgets = [{
'definition': {
'type' => 'timeseries',
'requests' => [
{'q' => 'sum:system.mem.free{*}'}
],
'title' => 'Sum Memory Free Shell'
}
}]
layout_type = 'ordered'
description = 'An updated dashboard with memory info.'
is_read_only = true
notify_list = ['user@domain.com']
template_variables = [{
'name' => 'host1',
'prefix' => 'host',
'default' => 'my-host'
}]
dog.update_board(dashboard_id, title, widgets, layout_type, {
'description' => description,
'is_read_only' => is_read_only,
'notify_list' => notify_list,
'template_variables' => template_variables
})
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
dashboard_id="<DASHBOARD_ID>"
curl -X PUT -H "Content-type: application/json" \
-d '{
"title" : "Sum of Memory Free",
"widgets" : [{
"definition": {
"type": "timeseries",
"requests": [
{"q": "sum:system.mem.free{*}"}
],
"title": "Sum Memory Free Shell"
}
}],
"layout_type": "ordered",
"description" : "An updated dashboard with memory info.",
"is_read_only": true,
"notify_list": ["user@domain.com"],
"template_variables": [{
"name": "host1",
"prefix": "host",
"default": "my-host"
}]
}' \
"https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}?api_key=${api_key}&application_key=${app_key}"
{
'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"
}
Delete an existing dashboard. This end point takes no JSON arguments.
DELETE https://api.datadoghq.com/api/v1/dashboard/<DASHBOARD_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
dashboard_id = '<DASHBOARD_ID>'
api.Dashboard.delete(dashboard_id)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dashboard_id = '<DASHBOARD_ID>'
dog.delete_board(dashboard_id)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
dashboard_id="<DASHBOARD_ID>"
curl -X DELETE "https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}?api_key=${api_key}&application_key=${app_key}"
{
'deleted_dashboard_id': 'qc9-tuk-9kv'
}
["200", {"deleted_dashboard_id" => "qc9-tuk-9kv"}]
{
"deleted_dashboard_id": "qc9-tuk-9kv"
}
Fetch an existing dashboard’s definition.
This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/dashboard/<DASHBOARD_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
dashboard_id = '<DASHBOARD_ID>'
api.Dashboard.get(dashboard_id)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dashboard_id = '<DASHBOARD_ID>'
dog.get_board(dashboard_id)
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
dashboard_id="<DASHBOARD_ID>"
curl "https://api.datadoghq.com/api/v1/dashboard/${dashboard_id}?api_key=${api_key}&application_key=${app_key}"
{
'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"
}
Interact with your dashboard lists through the API to make it easier to organize, find, and share all of your dashboards with your team and organization.
Fetch an existing dashboard list’s definition.
This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/dashboard/lists/manual/<LIST_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
api.DashboardList.get(4741)require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
result = dog.get_dashboard_list(4741)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
list_id=4741
curl -X GET \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}?api_key=${api_key}&application_key=${app_key}"{
'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
}Fetch all of your existing dashboard list definitions.
This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/dashboard/lists/manual
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
api.DashboardList.get_all()require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
result = dog.get_all_dashboard_lists()api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -X GET \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual?api_key=${api_key}&application_key=${app_key}"{
'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
}
]
}Create an empty dashboard list.
name [required]:
The name of the dashboard list.POST https://api.datadoghq.com/api/v1/dashboard/lists/manual
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
name = 'My Dashboard List'
api.DashboardList.create(name=name)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
name = 'My Dashboard List'
result = dog.create_dashboard_list(name)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -X POST -H "Content-type: application/json" \
-d '{
"name": "My Dashboard List"
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual?api_key=${api_key}&application_key=${app_key}"{
'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
}Update the name of a dashboard list
name [required]:
The name of the dashboard list.PUT https://api.datadoghq.com/api/v1/dashboard/lists/manual/<LIST_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
list_id = 4741
name = 'My Updated Dashboard List'
api.DashboardList.update(list_id, name=name)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
list_id = 4741
name = 'My Updated Dashboard List'
result = dog.update_dashboard_list(list_id, name)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
list_id=4741
curl -X PUT -H "Content-type: application/json" \
-d '{
"name": "My Updated Dashboard List"
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}?api_key=${api_key}&application_key=${app_key}"
{
'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
}Delete an existing dashboard list.
This end point takes no JSON arguments.
DELETE https://api.datadoghq.com/api/v1/dashboard/lists/manual/<LIST_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
api.DashboardList.delete(4741)require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
result = dog.delete_dashboard_list(4741)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
list_id=4741
curl -X DELETE \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}?api_key=${api_key}&application_key=${app_key}"{
'deleted_dashboard_list_id': 4741
}[
"200",
{
"deleted_dashboard_list_id" => 4741
}
]{
"deleted_dashboard_list_id": 4741
}Fetch the dashboard list’s dashboard definitions.
This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/dashboard/lists/manual/<LIST_ID>/dashboards
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
api.DashboardList.get_items(4741)require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
result = dog.get_items_of_dashboard_list(4741)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
list_id=4741
curl -X GET \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}/dashboards?api_key=${api_key}&application_key=${app_key}"{
'total': 5,
'dashboards': [
{
'is_shared': False,
'author': {
'handle': None,
'name': None
},
'url': '/screen/integration/66/aws-dynamodb',
'title': 'AWS DynamoDB',
'modified': None,
'created': None,
'is_favorite': True,
'is_read_only': True,
'type': 'integration_screenboard',
'id': 66,
'icon': '/static/v/34.254868/images/saas_logos/small/amazon_dynamodb.png'
},
{
'is_shared': False,
'author': {
'handle': None,
'name': None
},
'url': '/dash/integration/17/postgres---metrics',
'title': 'Postgres - Metrics',
'modified': None,
'created': None,
'is_favorite': True,
'is_read_only': True,
'type': 'integration_timeboard',
'id': 17,
'icon': '/static/v/34.254868/images/saas_logos/small/postgres.png'
},
{
'is_shared': False,
'author': {
'handle': 'test1@datadoghq.com',
'name': 'Author Name'
},
'url': '/dash/757575/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': 757575,
'icon': None
},
{
'is_shared': False,
'author': {
'handle': 'test2@datadoghq.com',
'name': 'Other Author Name'
},
'url': '/screen/7373/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': 7373,
'icon': None
},
{
'is_shared': False,
'author': {
'handle': None,
'name': None
},
'url': '/dash/host/123456789',
'title': 'agent-gui',
'modified': None,
'created': None,
'is_favorite': False,
'is_read_only': True,
'type': 'host_timeboard',
'id': 123456789,
'icon': None
}
]
}[
"200",
{
"total" => 5,
"dashboards" => [
{
"title" => "AWS DynamoDB",
"is_favorite" => true,
"id" => 66,
"icon" => "/static/v/34.254868/images/saas_logos/small/amazon_dynamodb.png",
"is_shared" => false,
"author" => {
"handle" => nil,
"name" => nil
},
"url" => "/screen/integration/66/aws-dynamodb",
"created" => nil,
"modified" => nil,
"is_read_only" => true,
"type" => "integration_screenboard"
},
{
"title" => "Postgres - Metrics",
"is_favorite" => true,
"id" => 17,
"icon" => "/static/v/34.254868/images/saas_logos/small/postgres.png",
"is_shared" => false,
"author" => {
"handle" => nil,
"name" => nil
},
"url" => "/dash/integration/17/postgres---metrics",
"created" => nil,
"modified" => nil,
"is_read_only" => true,
"type" => "integration_timeboard"
},
{
"title" => "Trace API",
"is_favorite" => false,
"id" => 757575,
"icon" => nil,
"is_shared" => false,
"author" => {
"handle" => "test1@datadoghq.com",
"name" => "Author Name"
},
"url" => "/dash/757575/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"
},
{
"title" => "Agent Stats",
"is_favorite" => false,
"id" => 7373,
"icon" => nil,
"is_shared" => false,
"author" => {
"handle" => "test2@datadoghq.com",
"name" => "Other Author Name"
},
"url" => "/screen/7373/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"
},
{
"title" => "agent-gui",
"is_favorite" => false,
"id" => 123456789,
"icon" => nil,
"is_shared" => false,
"author" => {
"handle" => nil,
"name" => nil
},
"url" => "/dash/host/123456789",
"created" => nil,
"modified" => nil,
"is_read_only" => true,
"type" => "host_timeboard"
}
]
}
]{
"total": 5,
"dashboards": [
{
"is_shared": False,
"author": {
"handle": None,
"name": None
},
"url": "/screen/integration/66/aws-dynamodb",
"title": "AWS DynamoDB",
"modified": None,
"created": None,
"is_favorite": True,
"is_read_only": True,
"type": "integration_screenboard",
"id": 66,
"icon": "/static/v/34.254868/images/saas_logos/small/amazon_dynamodb.png"
},
{
"is_shared": False,
"author": {
"handle": None,
"name": None
},
"url": "/dash/integration/17/postgres---metrics",
"title": "Postgres - Metrics",
"modified": None,
"created": None,
"is_favorite": True,
"is_read_only": True,
"type": "integration_timeboard",
"id": 17,
"icon": "/static/v/34.254868/images/saas_logos/small/postgres.png"
},
{
"is_shared": False,
"author": {
"handle": "test1@datadoghq.com",
"name": "Author Name"
},
"url": "/dash/757575/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": 757575,
"icon": None
},
{
"is_shared": False,
"author": {
"handle": "test2@datadoghq.com",
"name": "Other Author Name"
},
"url": "/screen/7373/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": 7373,
"icon": None
},
{
"is_shared": False,
"author": {
"handle": None,
"name": None
},
"url": "/dash/host/123456789",
"title": "agent-gui",
"modified": None,
"created": None,
"is_favorite": False,
"is_read_only": True,
"type": "host_timeboard",
"id": 123456789,
"icon": None
}
]
}Add dashboards to an existing dashboard list.
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.
POST https://api.datadoghq.com/api/v1/dashboard/lists/manual/<LIST_ID>/dashboards
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
list_id = 4741
dashboards = [
{
"type": "custom_screenboard",
"id": 1414
},
{
"type": "custom_timeboard",
"id": 5858
},
{
"type": "integration_screenboard",
"id": 67
},
{
"type": "integration_timeboard",
"id": 5
},
{
"type": "host_timeboard",
"id": 123456789
}
]
api.DashboardList.add_items(list_id, dashboards=dashboards)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
list_id = 4741
dashboards = [
{
"type" => "custom_screenboard",
"id" => 1414
},
{
"type" => "custom_timeboard",
"id" => 5858
},
{
"type" => "integration_screenboard",
"id" => 67
},
{
"type" => "integration_timeboard",
"id" => 5
},
{
"type" => "host_timeboard",
"id" => 123456789
}
]
result = dog.add_items_to_dashboard_list(list_id, dashboards)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
list_id=4741
curl -X POST -H "Content-type: application/json" \
-d '{
"dashboards": [
{
"type": "custom_screenboard",
"id": 1414
},
{
"type": "custom_timeboard",
"id": 5858
},
{
"type": "integration_screenboard",
"id": 67
},
{
"type": "integration_timeboard",
"id": 5
},
{
"type": "host_timeboard",
"id": 123456789
}
]
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}/dashboards?api_key=${api_key}&application_key=${app_key}"
{
'added_dashboards_to_list': [
{
'type': 'custom_timeboard',
'id': 5858
},
{
'type': 'custom_screenboard',
'id': 1414
},
{
'type': 'integration_timeboard',
'id': 5
},
{
'type': 'integration_screenboard',
'id': 67
},
{
'type': 'host_timeboard',
'id': 123456789
}
]
}[
"200",
{
"added_dashboards_to_list" => [
{
"type" => "custom_timeboard",
"id" => 5858
},
{
"type" => "custom_screenboard",
"id" => 1414
},
{
"type" => "integration_timeboard",
"id" => 5
},
{
"type" => "integration_screenboard",
"id" => 67
},
{
"type" => "host_timeboard",
"id" => 123456789
}
]
}
]{
"added_dashboards_to_list": [
{
"type": "custom_timeboard",
"id": 5858
},
{
"type": "custom_screenboard",
"id": 1414
},
{
"type": "integration_timeboard",
"id": 5
},
{
"type": "integration_screenboard",
"id": 67
},
{
"type": "host_timeboard",
"id": 123456789
}
]
}Update dashboards of an existing dashboard list.
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.
PUT https://api.datadoghq.com/api/v1/dashboard/lists/manual/<LIST_ID>/dashboards
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
list_id = 4741
dashboards = [
{
"type": "custom_screenboard",
"id": 1414
},
{
"type": "custom_timeboard",
"id": 5858
},
{
"type": "integration_screenboard",
"id": 67
},
{
"type": "integration_timeboard",
"id": 5
},
{
"type": "host_timeboard",
"id": 123456789
}
]
api.DashboardList.update_items(list_id, dashboards=dashboards)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
list_id = 4741
dashboards = [
{
"type" => "custom_screenboard",
"id" => 1414
},
{
"type" => "custom_timeboard",
"id" => 5858
},
{
"type" => "integration_screenboard",
"id" => 67
},
{
"type" => "integration_timeboard",
"id" => 5
},
{
"type" => "host_timeboard",
"id" => 123456789
}
]
result = dog.update_items_of_dashboard_list(list_id, dashboards)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
list_id=4741
curl -X PUT -H "Content-type: application/json" \
-d '{
"dashboards": [
{
"type": "custom_screenboard",
"id": 1414
},
{
"type": "custom_timeboard",
"id": 5858
},
{
"type": "integration_screenboard",
"id": 67
},
{
"type": "integration_timeboard",
"id": 5
},
{
"type": "host_timeboard",
"id": 123456789
}
]
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}/dashboards?api_key=${api_key}&application_key=${app_key}"
{
'dashboards': [
{
'type': 'custom_timeboard',
'id': 5858
},
{
'type': 'custom_screenboard',
'id': 1414
},
{
'type': 'integration_timeboard',
'id': 5
},
{
'type': 'integration_screenboard',
'id': 67
},
{
'type': 'host_timeboard',
'id': 123456789
}
]
}[
"200",
{
"dashboards" => [
{
"type" => "custom_timeboard",
"id" => 5858
},
{
"type" => "custom_screenboard",
"id" => 1414
},
{
"type" => "integration_timeboard",
"id" => 5
},
{
"type" => "integration_screenboard",
"id" => 67
},
{
"type" => "host_timeboard",
"id" => 123456789
}
]
}
]{
"dashboards": [
{
"type": "custom_timeboard",
"id": 5858
},
{
"type": "custom_screenboard",
"id": 1414
},
{
"type": "integration_timeboard",
"id": 5
},
{
"type": "integration_screenboard",
"id": 67
},
{
"type": "host_timeboard",
"id": 123456789
}
]
}Delete dashboards from an existing dashboard list.
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.
DELETE https://api.datadoghq.com/api/v1/dashboard/lists/manual/<LIST_ID>/dashboards
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
list_id = 4741
dashboards = [
{
"type": "custom_screenboard",
"id": 1414
},
{
"type": "custom_timeboard",
"id": 5858
},
{
"type": "integration_screenboard",
"id": 67
},
{
"type": "integration_timeboard",
"id": 5
},
{
"type": "host_timeboard",
"id": 123456789
}
]
api.DashboardList.delete_items(list_id, dashboards=dashboards)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
list_id = 4741
dashboards = [
{
"type" => "custom_screenboard",
"id" => 1414
},
{
"type" => "custom_timeboard",
"id" => 5858
},
{
"type" => "integration_screenboard",
"id" => 67
},
{
"type" => "integration_timeboard",
"id" => 5
},
{
"type" => "host_timeboard",
"id" => 123456789
}
]
result = dog.delete_items_from_dashboard_list(list_id, dashboards)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
list_id=4741
curl -X DELETE -H "Content-type: application/json" \
-d '{
"dashboards": [
{
"type": "custom_screenboard",
"id": 1414
},
{
"type": "custom_timeboard",
"id": 5858
},
{
"type": "integration_screenboard",
"id": 67
},
{
"type": "integration_timeboard",
"id": 5
},
{
"type": "host_timeboard",
"id": 123456789
}
]
}' \
"https://api.datadoghq.com/api/v1/dashboard/lists/manual/${list_id}/dashboards?api_key=${api_key}&application_key=${app_key}"
{
'deleted_dashboards_from_list': [
{
'type': 'custom_timeboard',
'id': 5858
},
{
'type': 'custom_screenboard',
'id': 1414
},
{
'type': 'integration_timeboard',
'id': 5
},
{
'type': 'integration_screenboard',
'id': 67
},
{
'type': 'host_timeboard',
'id': 123456789
}
]
}[
"200",
{
"deleted_dashboards_from_list" => [
{
"type" => "custom_timeboard",
"id" => 5858
},
{
"type" => "custom_screenboard",
"id" => 1414
},
{
"type" => "integration_timeboard",
"id" => 5
},
{
"type" => "integration_screenboard",
"id" => 67
},
{
"type" => "host_timeboard",
"id" => 123456789
}
]
}
]{
"deleted_dashboards_from_list": [
{
"type": "custom_timeboard",
"id": 5858
},
{
"type": "custom_screenboard",
"id": 1414
},
{
"type": "integration_timeboard",
"id": 5
},
{
"type": "integration_screenboard",
"id": 67
},
{
"type": "host_timeboard",
"id": 123456789
}
]
}Downtiming gives you greater control over monitor notifications by allowing you to globally exclude scopes from alerting. Downtime settings, which can be scheduled with start and end times, prevent all alerting related to specified Datadog tags.
scope [required]:
The scope(s) to which the downtime applies, e.g. host:app2. Provide multiple scopes as a comma-separated list, e.g. env:dev,env:prod. The resulting downtime applies to sources that matches ALL provided scopes (i.e. env:dev AND env:prod), NOT any of them.monitor_tags [optional, default=no monitor tag filter]:
A comma-separated list of monitor tags, i.e. tags that are applied directly to monitors, not tags that are used in monitor queries (which are filtered by the scope parameter), to which the downtime applies. The resulting downtime applies to monitors that match ALL provided monitor tags (i.e. service:postgres AND team:frontend), NOT any of them.monitor_id [optional, default=None]:
A single monitor to which the downtime applies. If not provided, the downtime applies to all monitors.start [optional, default=None]:
POSIX timestamp to start the downtime. If not provided, the downtime starts the moment it is created.end [optional, default=None]:
POSIX timestamp to end the downtime. If not provided, the downtime is in effect indefinitely (i.e. until you cancel it).message [optional, default=None]:
A message to include with notifications for this downtime. Email notifications can be sent to specific users by using the same ‘@username’ notation as eventstimezone [optional, default = UTC]:
The timezone for the downtime.recurrence [optional, default=None]:
An object defining the recurrence of the downtime with a variety of parameters:
type the type of recurrence. Choose from: days, weeks, months, years.period how often to repeat as an integer. For example to repeat every 3 days, select a type of days and a period of 3.week_days (optional) a list of week days to repeat on. Choose from: Mon, Tue, Wed, Thu, Fri, Sat or Sun. Only applicable when type is weeks. First letter must be capitalized.until_occurrences (optional) how many times the downtime is rescheduled. until_occurences and until_date are mutually exclusiveuntil_date (optional) the date at which the recurrence should end as a POSIX timestmap. until_occurences and until_date are mutually exclusivePOST https://api.datadoghq.com/api/v1/downtime
from datadog import initialize, api
import time
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Repeat for 3 hours (starting now) on every week day for 4 weeks.
start_ts = int(time.time())
end_ts = start_ts + (3 * 60 * 60)
end_reccurrence_ts = start_ts + (4 * 7 * 24 * 60 * 60) # 4 weeks from now
recurrence = {
'type': 'weeks',
'period': 1,
'week_days': ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
'until_date': end_reccurrence_ts
}
# Schedule downtime
api.Downtime.create(
scope='env:staging',
start=start_ts,
end=end_ts,
recurrence=recurrence
)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Repeat for 3 hours(starting now) on every week day for 4 weeks.
start_ts = Time.now.to_i
end_ts = start_ts + (3 * 60 * 60)
end_reccurrence_ts = start_ts + (4 * 7 * 24 * 60 * 60)# 4 weeks from now
recurrence = {
'type' => 'weeks',
'period' => 1,
'week_days' => ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
'until_date' => end_reccurrence_ts
}
# Schedule downtime
dog.schedule_downtime('env:testing', :start => start_ts, :end => end_ts, :recurrence => recurrence)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
start=$(date +%s)
end=$(date -v+3H +%s)
end_recurrence=$(date -v+21d +%s)
curl -X POST -H "Content-type: application/json" \
-d '{
"scope": "env:prod",
"start": '"${start}"',
"end": '"${end}"',
"recurrence": {
"type": "weeks",
"period": 1,
"week_days": ["Mon", "Tue", "Wed", "Thu", "Fri"],
"until_date": '"${end_recurrence}"'
}
}' \
"https://api.datadoghq.com/api/v1/downtime?api_key=${api_key}&application_key=${app_key}"
{
'active': True,
'canceled': None,
'creator_id': 3658,
'disabled': False,
'end': 1445978817,
'id': 169267576,
'message': None,
'monitor_id': None,
'monitor_tags': ['*'],
'parent_id': None,
'recurrence': {
'period': 1,
'type': 'weeks',
'until_date': 1448387217,
'until_occurrences': None,
'week_days': [
'Mon',
'Tue',
'Wed',
'Thu',
'Fri'
]
},
'scope': ['env:staging'],
'start': 1445968017,
'updater_id': None
}
[
"200", {
"disabled" => false,
"canceled" => nil,
"active" => true,
"message" => nil,
"id" => 169267581,
"end" => 1445978819,
"parent_id" => nil,
"monitor_id" => nil,
"monitor_tags": ["*"],
"recurrence" => {
"until_date" => 1448387219,
"until_occurrences" => nil,
"week_days" => ["Mon", "Tue", "Wed", "Thu", "Fri"],
"type" => "weeks",
"period" => 1
},
"start" => 1445968019,
"creator_id" => 3658,
"scope" => ["env:testing"],
"updater_id" => nil
}
]
{
"active": true,
"canceled": null,
"creator_id": 3658,
"disabled": false,
"end": 1445979093,
"id": 169267786,
"message": null,
"monitor_id": null,
"monitor_tags": ["*"],
"parent_id": null,
"recurrence": {
"period": 1,
"type": "weeks",
"until_date": 1447786293,
"until_occurrences": null,
"week_days": [
"Mon",
"Tue",
"Wed",
"Thu",
"Fri"
]
},
"scope": [
"env:prod"
],
"start": 1445968293,
"updater_id": null
}
id [required]:
The integer id of the downtime to be updatedscope [required]:
The scope to which the downtime applies, e.g. ‘host:app2’. Provide multiple scopes as a comma-separated list, e.g. ‘env:dev,env:prod’. The resulting downtime applies to sources that matches ALL provided scopes (i.e. env:dev AND env:prod), NOT any of them.monitor_tags [optional, default=no monitor tag filter]:
A comma-separated list of monitor tags, i.e. tags that are applied directly to monitors, not tags that are used in monitor queries (which are filtered by the scope parameter), to which the downtime applies. The resulting downtime applies to monitors that match ALL provided monitor tags (i.e. service:postgres AND team:frontend), NOT any of them.monitor_id [optional, default=None]:
A single monitor to which the downtime applies. If not provided, the downtime applies to all monitors.start [optional, default = original start]:
POSIX timestamp to start the downtime.end [optional, default = original end]:
POSIX timestamp to end the downtime. If not provided, the downtime is in effect indefinitely (i.e. until you cancel it).message [required, default = original message]:
A message to include with notifications for this downtime. Email notifications can be sent to specific users by using the same ‘@username’ notation as eventstimezone [optional, default = original timezone ]:
The timezone for the downtime.recurrence [optional, default = original recurrence]:
An object defining the recurrence of the downtime with a variety of parameters:
type the type of recurrence. Choose from: days, weeks, months, years.period how often to repeat as an integer. For example to repeat every 3 days, select a type of days and a period of 3.week_days (optional) a list of week days to repeat on. Choose from: Mon, Tue, Wed, Thu, Fri, Sat or Sun. Only applicable when type is weeks. First letter must be capitalized.until_occurrences (optional) how many times the downtime is rescheduled. until_occurences and until_date are mutually exclusiveuntil_date (optional) the date at which the recurrence should end as a POSIX timestmap. until_occurences and until_date are mutually exclusivePUT https://api.datadoghq.com/api/v1/downtime/<DOWNTIME_ID>
from datadog import initialize, api
import time
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Get an existing downtime
stagingDowntimes = []
downtimes = api.Downtime.get_all()
for item in downtimes:
if item['scope'] == ['env:staging']:
stagingDowntimes.append(item)
# Update that downtime
api.Downtime.update(
stagingDowntimes[0]['id'],
scope='env:staging',
end=int(time.time()) + 60000,
message="Doing some testing on staging."
)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Update downtime
stagingDowntimes = []
downtimes = dog.get_all_downtimes()
downtimes[1].each do |item |
print item['scope']
if item['scope'] == ['env:staging']
stagingDowntimes.push item
end
end
dog.update_downtime(stagingDowntimes[0]['id'], :scope => 'env:testing', :end => Time.now.to_i + 60000, :message => "Doing some testing on staging.")api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
downtime_id=4336
# Create a downtime to update
currenttime=$(date +%s)
downtime_id=$(curl -X POST -H "Content-type: application/json" \
-d "{
\"scope\": \"env:prod\",
\"start\": \"${currenttime}\"
}" \
"https://api.datadoghq.com/api/v1/downtime?api_key=${api_key}&application_key=${app_key}" | jq '.id')
curl -X PUT -H "Content-type: application/json" \
-d '{
"scope": "env:staging",
"message": "Doing some testing on staging"
}' \
"https://api.datadoghq.com/api/v1/downtime/${downtime_id}?api_key=${api_key}&application_key=${app_key}"
{
'active': True,
'disabled': False,
'end': 1420447087,
'id': 2910,
'message': 'Doing some testing on staging.',
'monitor_tags': ['*'],
'scope': ['env:staging'],
'start': 1420387032
}
[
"200", {
"end" => 1418303372,
"disabled" => false,
"start" => 1418224729,
"active" => true,
"monitor_tags": ["*"],
"scope" => ["env:testing"],
"message" => "Doing some testing on staging.",
"id" => 4336
}
]
{
"active": true,
"disabled": false,
"end": 1418303372,
"id": 4336,
"message": "Doing some testing on staging",
"monitor_tags": ["*"],
"scope": [
"env:staging"
],
"start": 1418224729
}
id [required]:DELETE https://api.datadoghq.com/api/v1/downtime/<DOWNTIME_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Cancel downtime
api.Downtime.delete(1654)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Cancel downtime
dog.cancel_downtime(1655)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
downtime_id=1656
# Create a downtime to delete
currenttime=$(date +%s)
downtime_id=$(curl -X POST -H "Content-type: application/json" \
-d "{
\"scope\": \"env:prod\",
\"start\": \"${currenttime}\"
}" \
"https://api.datadoghq.com/api/v1/downtime?api_key=${api_key}&application_key=${app_key}" | jq '.id')
curl -X DELETE -H "Content-type: application/json" "https://api.datadoghq.com/api/v1/downtime/${downtime_id}?api_key=${api_key}&application_key=${app_key}"This end point does not return JSON on successful requests.
scope [required]:
Cancel all downtimes with the given scope(s), e.g.:
POST https://api.datadoghq.com/api/v1/downtime/cancel/by_scope
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/bash
api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"
curl -X POST -H "Content-type: application/json" -H "Accept: application/json" \
-d "{
\"scope\": \"host:i-123\"
}" \
"https://api.datadoghq.com/api/v1/downtime/cancel/by_scope?api_key=${api_key}&application_key=${app_key}"#
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
#
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example {
"cancelled_ids":[123456789,123456790]
}This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/downtime/<DOWNTIME_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Get a downtime
api.Downtime.get(2910)
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
downtime_id=2473
curl "https://api.datadoghq.com/api/v1/downtime/${downtime_id}?api_key=${api_key}&application_key=${app_key}"{'active': True,
'disabled': False,
'end': 1420447087,
'id': 2910,
'message': 'Doing some testing on staging.',
'monitor_tags': ['*'],
'scope': ['env:staging'],
'start': 1420387032
}
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
{
"active": True,
"disabled": False,
"end": 1420447087,
"id": 2910,
"message": "Doing some testing on staging.",
"monitor_tags": ["*"],
"scope": ["env:staging"],
"start": 1420387032
}
current_only [optional, default = False]:GET https://api.datadoghq.com/api/v1/downtime
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Get all downtimes
print api.Downtime.get_all()
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get all downtimes
print(dog.get_all_downtimes())api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -G "https://api.datadoghq.com/api/v1/downtime" \
-d "api_key=${api_key}" \
-d "application_key=${app_key}"
[
{
'active': False,
'disabled': True,
'end': 1412793983,
'id': 1625,
'monitor_tags': ['*'],
'scope': ['env:staging'],
'start': 1412792983
},
{
'active': False,
'disabled': True,
'end': None,
'id': 1626,
'monitor_tags': ['*'],
'scope': ['*'],
'start': 1412792985
}
]
[
"200", [{
"end" => 1412793983,
"disabled" => true,
"start" => 1412792983,
"active" => false,
"monitor_tags" => ["*"],
"scope" => ["env:staging"],
"id" => 1625
}, {
"end" => nil,
"disabled" => true,
"start" => 1412792985,
"active" => false,
"monitor_tags" => ["*"],
"scope" => ["*"],
"id" => 1626
}]
]
[
{
"active": false,
"disabled": true,
"end": 1412793983,
"id": 1625,
"monitor_tags": ["*"],
"scope": [
"env:staging"
],
"start": 1412792983
},
{
"active": false,
"disabled": true,
"end": null,
"id": 1626,
"monitor_tags": ["*"],
"scope": [
"*"
],
"start": 1412792985
}
]
Interact with embeddable graphs through the API.
Gets a list of previously created embeddable graphs.
Returns: A JSON list containing information on previously created embeds from both the UI and the API. Each JSON graph response is in the same format as returned by GET api/v1/graph/embed/
This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/graph/embed
from datadog import initialize, api
# Intialize request parameters including API/APP key
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Call Embed API function
api.Embed.get_all()
require 'rubygems'
require 'dogapi'
# Initialize API Client
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get all with API Call
dog.get_all_embeds()api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"
curl -X GET "https://api.datadoghq.com/api/v1/graph/embed?api_key=${api_key}&application_key=${app_key}"
{
"embedded_graphs": [
{
"embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
"template_variables": [],
"html": '<iframe src="https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&height=300&width=600&legend=true" width="600" height="300" frameBorder="0"></iframe>',
"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" => '<iframe src="https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&height=300&width=600&legend=true" width="600" height="300" frameBorder="0"></iframe>',
"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": "<iframe src=\"https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&height=300&width=600&legend=true\" width=\"600\" height=\"300\" frameBorder=\"0\"></iframe>",
"graph_title": "Embed created through API",
"revoked": false,
"dash_url": null,
"shared_by": 3658,
"dash_name": null
}
]
}
Creates a new embeddable graph.
Returns: A JSON consisting of the same elements returned by GET api/v1/graph/embed/
Note: If an embed already exists for the exact same query in a given organization, the older embed is returned instead of creating a new embed.
If you are interested in using template variables, see Embeddable Graphs with Template Variables.
graph_json [required]:timeframe [optional, default=1_hour]:size [optional, default=medium]:legend [optional, default=no]:title [optional, default=Embed created through API]:POST https://api.datadoghq.com/api/v1/graph/embed
from datadog import initialize, api
import json
# Intialize request parameters including API/APP key
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Create an embed graph definition as a dict and format as JSON
graph_json = {
"requests": [{
"q": "avg:system.load.1{*}"
}],
"viz": "timeseries",
"events": []
}
graph_json = json.dumps(graph_json)
api.Embed.create(
graph_json=graph_json,
timeframe="1_hour",
size="medium",
legend="no"
)
require 'rubygems'
require 'dogapi'
# Initialize API Client
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Prepare parameters
graph_json = '{
"requests": [{
"q": "avg:system.load.1{*}"
}],
"viz": "timeseries",
"events": []
}
'
timeframe = "1_hour"
size = "medium"
legend = "no"
title = "Embed created through API"
# Create parameter hash
description = {:timeframe => timeframe, :size => size, :legend => legend, :title => title
}
# Make API Call
status, result = dog.create_embed(graph_json, description)api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"
curl -POST \
-d 'graph_json={"requests":[{"q":"avg:system.load.1{*}"}],"viz":"timeseries","events":[]}' \
-d "timeframe=1_hour" \
-d "size=medium" \
-d "legend=yes" \
"https://api.datadoghq.com/api/v1/graph/embed?api_key=${api_key}&application_key=${app_key}"
{
"embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
"template_variables": [],
"html": '<iframe src="https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&height=300&width=600&legend=true" width="600" height="300" frameBorder="0"></iframe>',
"graph_title": "Embed created through API",
"revoked": False,
"dash_url": None,
"shared_by": 3658,
"dash_name": None
}
{
"embed_id" => "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
"template_variables" => [],
"html" => '<iframe src="https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&height=300&width=600&legend=true" width="600" height="300" frameBorder="0"></iframe>',
"graph_title" => "Embed created through API",
"revoked" => false,
"dash_url" => nil,
"shared_by" => 3658,
"dash_name" => nil
}{
"embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
"template_variables": [],
"html": "<iframe src=\"https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&height=300&width=600&legend=true\" width=\"600\" height=\"300\" frameBorder=\"0\"></iframe>",
"graph_title": "Embed created through API",
"revoked": false,
"dash_url": null,
"shared_by": 3658,
"dash_name": null
}
Get the HTML fragment for a previously generated embed with embed_id.
Returns: A JSON object with 8 elements:
On failure, the return value is a JSON containing an error message {errors: [messages]}.
size [optional, default=medium]:legend [optional, default=no]:template_variables [optional, default=None]:GET https://api.datadoghq.com/api/v1/graph/embed/<EMBED_ID>
from datadog import initialize, api
# Intialize request parameters including API/APP key
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Set Embed ID (token)
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Call Embed API function
api.Embed.get(embed_id, legend="no", size="medium", timeframe="1_hour")
require 'rubygems'
require 'dogapi'
# Initialize API Client
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Initialize Embed Token / ID
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Get embed with API Call
dog.enable_embed(embed_id)api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"
embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
curl -X GET "https://api.datadoghq.com/api/v1/graph/embed/${embed_id}?api_key=${api_key}&application_key=${app_key}"
{
"embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
"template_variables": [],
"html": '<iframe src="https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&height=300&width=600&legend=true" width="600" height="300" frameBorder="0"></iframe>',
"graph_title": "Embed created through API",
"revoked": False,
"dash_url": None,
"shared_by": 3658,
"dash_name": None
}
{
"embed_id" => "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
"template_variables" => [],
"html" => '<iframe src="https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&height=300&width=600&legend=true" width="600" height="300" frameBorder="0"></iframe>',
"graph_title" => "Embed created through API",
"revoked" => false,
"dash_url" => nil,
"shared_by" => 3658,
"dash_name" => nil
}{
"embed_id": "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c",
"template_variables": [],
"html": "<iframe src=\"https://app.datadoghq.com/graph/embed?token=5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c&height=300&width=600&legend=true\" width=\"600\" height=\"300\" frameBorder=\"0\"></iframe>",
"graph_title": "Embed created through API",
"revoked": false,
"dash_url": null,
"shared_by": 3658,
"dash_name": null
}
Enable a specified embed.
Returns: A JSON containing the success message {success: [message]}. On failure, the return value is a JSON containing an error message {errors: [messages]}.
This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/graph/embed/<EMBED_ID>/enable
from datadog import initialize, api
# Intialize request parameters including API/APP key
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Set Embed ID (token)
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Call Embed API function
api.Embed.enable(embed_id)
require 'rubygems'
require 'dogapi'
# Initialize API Client
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Initialize Embed Token / ID
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Enable with API Call
dog.enable_embed(embed_id)api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"
embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
curl -X GET "https://api.datadoghq.com/api/v1/graph/embed/${embed_id}/enable?api_key=${api_key}&application_key=${app_key}"
{
"success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully enabled."
}
{
"success" => "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully enabled."
}{
"success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully enabled."
}
Revoke a specified embed.
Returns: A JSON containing the success message {success: [message]}. On failure, the return value is a JSON containing an error message {errors: [messages]}.
This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/graph/embed/<EMBED_ID>/revoke
from datadog import initialize, api
# Intialize request parameters including API/APP key
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Set Embed ID (token)
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Call Embed API function
api.Embed.revoke(embed_id)
require 'rubygems'
require 'dogapi'
# Initialize API Client
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Initialize Embed Token / ID
embed_id = "5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
# Revoke with API Call
dog.revoke_embed(embed_id)api_key="<YOUR_API_KEY>"
app_key="<YOUR_APP_KEY>"
embed_id="5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c"
curl -X GET "https://api.datadoghq.com/api/v1/graph/embed/${embed_id}/revoke?api_key=${api_key}&application_key=${app_key}"
{
"success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully revoked."
}
{
"success" => "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully revoked."
}{
"success": "Embed 5f585b01c81b12ecdf5f40df0382738d0919170639985d3df5e2fc4232865b0c successfully revoked."
}
The events service allows you to programatically post events to the event stream and fetch events from the event stream.
Events are limited to 4000 characters. If an event is sent out with a message containing more than 4000 characters only the 4000 first characters are displayed.
This end point allows you to post events to the stream. Tag them, set priority and event aggregate them with other events.
title [required]:msg_title with the Datadog Ruby library.text [required]:msg_text with the Datadog Ruby librarydate_happened [optional, default = now]:priority [optional, default = normal]:host [optional, default=None]:tags [optional, default=None]:alert_type [optional, default = info]:aggregation_key [optional, default=None]:source_type_name [optional, default=None]:POST https://api.datadoghq.com/api/v1/events
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
title = "Something big happened!"
text = 'And let me tell you all about it here!'
tags = ['version:1', 'application:web']
api.Event.create(title=title, text=text, tags=tags)
# If you are programmatically adding a comment to this new event
# you might want to insert a pause of .5 - 1 second to allow the
# event to be available.
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# submitting events doesn 't require an application_key,
# so we don't bother setting it
dog = Dogapi::Client.new(api_key)
dog.emit_event(Dogapi::Event.new('msg_text', :msg_title => 'Title'))
# If you are programmatically adding a comment to this new event
# you might want to insert a pause of.5 - 1 second to allow the
# event to be available.
curl -X POST -H "Content-type: application/json" \
-d '{
"title": "Did you hear the news today?",
"text": "Oh boy!",
"priority": "normal",
"tags": ["environment:test"],
"alert_type": "info"
}' \
'https://api.datadoghq.com/api/v1/events?api_key=<YOUR_API_KEY>'
{
'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"
}This end point allows you to query for event details. Note: if the event you’re querying contains markdown formatting of any kind, you may see characters such as %,\,n in your output
This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/events/<EVENT_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
api.Event.get(2603387619536318140)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
event_id = '1375909614428331251'
dog.get_event(event_id)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
event_id=1377281704830403917
# Create an event to get
event_id=$(curl -X POST -H "Content-type: application/json" -d "{\"title\": \"Did you hear the news today?\"}" "https://api.datadoghq.com/api/v1/events?api_key=<YOUR_API_KEY>" | jq -r '.event.url|ltrimstr("https://app.datadoghq.com/event/event?id=")')
sleep 5
curl "https://api.datadoghq.com/api/v1/events/${event_id}?api_key=${api_key}&application_key=${app_key}"
{
'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"
}
}This end point allows you to delete an event.
This end point takes no JSON arguments.
DELETE https://api.datadoghq.com/api/v1/events/<EVENT_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
api.Event.delete(2603387619536318140)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.delete_event(1375909614428331251)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
event_id=1377281704830403917
curl -X DELETE "https://api.datadoghq.com/api/v1/events/${event_id}?api_key=${api_key}&application_key=${app_key}"
{
"deleted_event_id": "2603387619536318140"
}
[
"200", {
"deleted_event_id" => "1375909614428331251"
}
]
{
"deleted_event_id": "1377281704830403917"
}
The event stream can be queried and filtered by time, priority, sources and tags. Note: if the event you’re querying contains markdown formatting of any kind, you may see characters such as %,\,n in your output
start [required]:end [required]:priority [optional, default=None]:sources [optional, default=None]:tags [optional, default=None]:unaggregated [optional, default=false]:
Set unaggregated to true to return all events within the specified [start,end] timeframe. Otherwise if an event is aggregated to a parent event with a timestamp outside of the timeframe, it won’t be available in the output.GET https://api.datadoghq.com/api/v1/events
from datadog import initialize, api
import time
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
end_time = time.time()
start_time = end_time - 100
api.Event.query(
start=start_time,
end=end_time,
priority="normal",
tags=["application:web"],
unaggregated=True
)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
end_time = Time.now.to_i
start_time = end_time - 100
dog.stream(start_time, end_time, :priority => "normal", :tags => ["application:web"], :unaggregated => true)# Note: this end point only accepts form-encoded requests.
currenttime=$(date +%s)
currenttime2=$(date --date='1 day ago' +%s)
curl -G -H "Content-type: application/json" \
-d "start=${currenttime2}" \
-d "end=${currenttime}" \
-d "sources=My Apps" \
-d "tags=application:web,version:1" \
-d "unaggregated=true"\
-d "api_key=<YOUR_API_KEY>" \
-d "application_key=<YOUR_APP_KEY>" \
'https://api.datadoghq.com/api/v1/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'
}
]
}
["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"
}
]
}Take graph snapshots using the API.
Note: When a snapshot is created, there is some delay before it is available.
metric_query [required]:start [required]:end [required]:event_query [optional, default=None]:graph_def [optional, default=None]:graph_def can be used instead of metric_query. The JSON document uses the grammar defined here and should be formatted to a single line then URLEncoded.title [optional, default=None]:GET https://api.datadoghq.com/api/v1/graph/snapshot
from datadog import initialize, api
import time
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Take a graph snapshot
end = int(time.time())
start = end - (60 * 60)
api.Graph.create(
graph_def='{\
"viz": "timeseries", \
"requests": [ \
{"q": "avg:system.load.1{*}", "conditional_formats": [], "type": "line"},\
{"q": "avg:system.load.5{*}", "type": "line"}, \
{"q": "avg:system.load.15{*}", "type": "line"}\
], \
"events": [\
{"q": "hosts:* ", "tags_execution": "and"}\
]}',
start=start,
end=end
)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
end_ts = Time.now().to_i
start_ts = end_ts - (60 * 60)
dog.graph_snapshot("system.load.1{*}", start_ts, end_ts)
currenttime=$(date +%s)
currenttime2=$(date -v -1d +%s)
curl -G -H "Content-type: application/json" \
-d "metric_query=system.load.1{*}" \
-d "start=${currenttime2}" \
-d "end=${currenttime}" \
-d "api_key=<YOUR_API_KEY>" \
-d "application_key=<YOUR_APP_KEY>" \
'https://api.datadoghq.com/api/v1/graph/snapshot'
{
'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"
}
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 100 results at a time.
filter [optional, default=None]:
Query string to filter search results.sort_field [optional, default=cpu]:
Sort hosts by the given field.
Options: status, apps, cpu, iowait, loadsort_dir [optional, default=desc]:
Direction of sort.
Options: asc, descstart [optional, default=0]:
Host result to start search from.count [optional, default=100]:
Number of host results to return. Max 100.GET https://api.datadoghq.com/api/v1/hosts
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
api.Hosts.search()
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.search_hosts()
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -G "https://api.datadoghq.com/api/v1/hosts" \
-d "api_key=${api_key}" \
-d "application_key=${app_key}"
{
'total_returned': 1,
'host_list': [
{
'name': 'i-deadbeef',
'up': True,
'is_muted': False,
'apps': [
'agent'
],
'tags_by_source': {
'Datadog': [
'host:i-deadbeef'
],
'Amazon Web Services': [
'account:staging'
]
},
'aws_name': 'mycoolhost-1',
'metrics': {
'load': 0.5,
'iowait': 3.2,
'cpu': 99.0
},
'sources': [
'aws',
'agent'
],
'meta': {
'nixV': [
'Ubuntu',
'14.04',
'trusty'
]
},
'host_name': 'i-deadbeef',
'id': 123456,
'aliases': [
'mycoolhost-1'
]
}
],
'total_matching': 1
}
["200", {
"total_returned": 1,
"host_list": [
{
"name": "i-deadbeef",
"up": true,
"is_muted": false,
"apps": [
"agent"
],
"tags_by_source": {
"Datadog": [
"host:i-deadbeef"
],
"Amazon Web Services": [
"account:staging"
]
},
"aws_name": "mycoolhost-1",
"metrics": {
"load": 0.5,
"iowait": 3.2,
"cpu": 99.0
},
"sources": [
"aws",
"agent"
],
"meta": {
"nixV": [
"Ubuntu",
"14.04",
"trusty"
]
},
"host_name": "i-deadbeef",
"id": 123456,
"aliases": [
"mycoolhost-1"
]
}
],
"total_matching": 1
}]
{
"total_returned": 1,
"host_list": [
{
"name": "i-deadbeef",
"up": true,
"is_muted": false,
"apps": [
"agent"
],
"tags_by_source": {
"Datadog": [
"host:i-deadbeef"
],
"Amazon Web Services": [
"account:staging"
]
},
"aws_name": "mycoolhost-1",
"metrics": {
"load": 0.5,
"iowait": 3.2,
"cpu": 99.0
},
"sources": [
"aws",
"agent"
],
"meta": {
"nixV": [
"Ubuntu",
"14.04",
"trusty"
]
},
"host_name": "i-deadbeef",
"id": 123456,
"aliases": [
"mycoolhost-1"
]
}
],
"total_matching": 1
}
This endpoint returns the total number of active and up hosts in your Datadog account. Active means the host has reported in the past hour, and up means it has reported in the past two hours.
This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/hosts/totals
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
api.Hosts.totals()
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.host_totals()
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -G "https://api.datadoghq.com/api/v1/hosts/totals" \
-d "api_key=${api_key}" \
-d "application_key=${app_key}"
{'total_up':1750,'total_active':1759}
["200", {"total_up":1750,"total_active":1759}]
{"total_up":1750,"total_active":1759}
end [optional, default=None]:
POSIX timestamp when the host is unmuted. If omitted, the host remains muted until explicitly unmuted.message [optional, default=None]:
Message to associate with the muting of this host.override [optional, default=False]:
If true and the host is already muted, replaces existing host mute settings.POST https://api.datadoghq.com/api/v1/host/<HOSTNAME>/mute
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Find a host to mute
hosts = api.Hosts.search(q='hosts:')
# Mute a host
api.Host.mute(hosts['results']['hosts'][0])
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
hostname = "test.host"
message = "Muting this host for a test."
end_ts = Time.now.to_i + 60 * 60
dog.mute_host(hostname, :message => message, :end => end_ts)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -X POST -H "Content-type: application/json" \
-d '{
"message": "Muting this host for a test!"
}' "https://api.datadoghq.com/api/v1/host/test.host/mute?api_key=${api_key}&application_key=${app_key}"
{
'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!"
}
This end point takes no JSON arguments.
POST https://api.datadoghq.com/api/v1/host/<HOSTNAME>/unmute
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Find a host to unmute
hosts = api.Hosts.search(q='hosts:')
# Unmute host
api.Host.unmute(hosts['results']['hosts'][0])
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
hostname = "test.host"
dog.unmute_host(hostname)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -X POST -H "Content-type: application/json" "https://api.datadoghq.com/api/v1/host/test.host/unmute?api_key=${api_key}&application_key=${app_key}"
{
'action': 'Unmuted',
'hostname': 'test.host'
}
["200", {
"action" => "Unmuted",
"hostname" => "test.host"
}]{
"action": "Unmuted",
"hostname": "test.host"
}Configure your Datadog integrations via Datadog API, current configurable integrations are:
Available endpoints are:
To create an integration or append its configuration in Datadog:
POST /api/v1/integration/<SOURCE_TYPE_NAME>
To read an integration configuration:
GET /api/v1/integration/<SOURCE_TYPE_NAME>
To delete an integration from Datadog:
DELETE /api/v1/integration/<SOURCE_TYPE_NAME>
Configure your Datadog-AWS integration directly through Datadog API.
Read more about Datadog-AWS integration.
Note: Using the POST method updates your integration configuration by adding your new configuration to the existing one in your Datadog organization.
account_id [required]:
Your AWS Account ID without dashes. Consult the Datadog AWS integration to learn more about your AWS account ID.
access_key_id [optional, default=None]:
If your AWS account is a GovCloud or China account, enter the corresponding Access Key ID.
role_name [required]:
Your Datadog role delegation name. Consult the Datadog AWS integration to learn more about your AWS account Role name.
filter_tags [optional, default=None]:
Array of EC2 tags (in the form key:value) defines a filter that Datadog use 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
Read more about EC2 tagging in 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 https://api.datadoghq.com/api/v1/integration/aws/available_namespace_rules endpoint.
https://api.datadoghq.com/api/v1/integration/aws
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example #!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account
api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>
# List AWS Accounts (role-based only) in Datadog
curl -X GET "https://api.datadoghq.com/api/v1/integration/aws?api_key=${api_key}&application_key=${app_key}"
# Create an AWS Account in Datadog
curl -X POST -H "Content-type: application/json" \
-d '{
"account_id": "<AWS_ACCOUNT_ID>",
"filter_tags": ["<KEY>:<VALUE>"],
"host_tags": ["<KEY>:<VALUE>"],
"role_name": "DatadogAWSIntegrationRole",
"account_specific_namespace_rules": {
"auto_scaling": false,
"opsworks": false
}
}'\
"https://api.datadoghq.com/api/v1/integration/aws?api_key=${api_key}&application_key=${app_key}"
# Delete an AWS Account in Datadog
curl -X DELETE -H "Content-type: application/json" \
-d '{
"account_id": "<AWS_ACCOUNT_ID>",
"role_name": "DatadogAWSIntegrationRole"
}' \
"https://api.datadoghq.com/api/v1/integration/aws?api_key=${api_key}&application_key=${app_key}"
# List available namespace rules
curl -X GET "https://api.datadoghq.com/api/v1/integration/aws/available_namespace_rules?api_key=${api_key}&application_key=${app_key}"
# 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 # List AWS Accounts (role-based only) in Datadog
{"accounts":
[{
"account_id": '112233445566',
"role_name": "SomeDatadogRole",
"filter_tags": ["filter123"],
"host_tags": ["account":"demo"],
"account_specific_namespace_rules": {"opsworks":false}
}]
}
# Create an AWS Account in Datadog
{'external_id': '123456789'}
# Delete an AWS Account in Datadog
OKConfigure your Datadog-Azure integration directly through the Datadog API.
Read more about Datadog-Azure integration.
Note:
POST method updates your integration configuration by adding your new configuration to the existing one in your Datadog organization.Refer to the Datadog-Azure integration installation instructions to see how to obtain the following field values for your organization.
tenant_name [required]:
Your Azure Active Directory ID.
client_id [required]:
Your Azure web application ID.
client_secret [required]:
Your Azure web application secret key.
host_filters [optional, default=None]:
Limit the Azure instances that are pulled into Datadog by using tags. Only hosts that match one of the defined tags are imported into Datadog.
https://api.datadoghq.com/api/v1/integration/azure
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example #!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account
api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>
# List Azure accounts in Datadog
curl -X GET "https://app.datadoghq.com/api/v1/integration/azure?api_key=${api_key}&application_key=${app_key}"
# Create an Azure account in Datadog
curl -X POST -H "Content-type: application/json" \
-d '{
"tenant_name": "<AZURE_TENANT_NAME>",
"client_id": "<AZURE_CLIENT_ID>",
"client_secret": "<AZURE_CLIENT_SECRET>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}' \
"https://app.datadoghq.com/api/v1/integration/azure?api_key=${api_key}&application_key=${app_key}"
# Update an Azure account's host filters in Datadog
# tenant_name and client_id are required
curl -X POST -H "Content-type: application/json" \
-d '{
"tenant_name": "<AZURE_TENANT_NAME>",
"client_id": "<AZURE_CLIENT_ID>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}' \
"https://app.datadoghq.com/api/v1/integration/azure/host_filters?api_key=${api_key}&application_key=${app_key}"
# Delete an Azure account in Datadog
# tenant_name and client_id are required
curl -X DELETE -H "Content-type: application/json" \
-d '{
"tenant_name": "<AZURE_TENANT_NAME>",
"client_id": "<AZURE_CLIENT_ID>"
}' \
"https://app.datadoghq.com/api/v1/integration/azure?api_key=${api_key}&application_key=${app_key}"
# 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 OKConfigure your Datadog-Google Cloud Platform integration directly through the Datadog API.
Read more about Datadog-Google Cloud Platform integration.
Note:
Using the POST method updates your integration configuration by adding your new configuration to the existing one in your Datadog organization.
Using the PUT method updates the existing integration configuration in your Datadog organization.
All of the following fields’ values are provided by the JSON service account key file created in the GCP Console for service accounts; Refer to the Datadog-Google Cloud Platform integration installation instructions to see how to generate one for your organization. For further references, consult the Google Cloud service account documentation.
type [required]:
Should be service_account, it can be found in your JSON service account key.
project_id [required]:
Your Google Cloud project ID found in your JSON service account key.
private_key_id [required]:
Your private key ID found in your JSON service account key.
private_key [required]:
Your private key name found in your JSON service account key.
client_email [required]:
Your email found in your JSON service account key.
client_id [required]:
Your ID found in your JSON service account key.
auth_uri [required]:
Should be https://accounts.google.com/o/oauth2/auth.
token_uri [required]:
Should be https://accounts.google.com/o/oauth2/token.
auth_provider_x509_cert_url [required]:
Should be https://www.googleapis.com/oauth2/v1/certs.
client_x509_cert_url [required]:
Should be https://www.googleapis.com/robot/v1/metadata/x509/<CLIENT_EMAIL> where <CLIENT_EMAIL> is the email found in your JSON service account key.
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.
automute [optional, default=false]:
Silence monitors for expected GCE instance shutdowns.
https://api.datadoghq.com/api/v1/integration/gcp
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example #!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account
api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>
# List GCP Accounts (service accounts only) in Datadog
curl -X GET "https://app.datadoghq.com/api/v1/integration/gcp?api_key=${api_key}&application_key=${app_key}"
# Create a GCP Service Account in Datadog
curl -X POST -H "Content-type: application/json" \
-d '{
"type": "service_account",
"project_id": "<GCP_PROJECT_ID>",
"private_key_id": "<PRIVATE_KEY_ID>",
"private_key": "<PRIVATE_KEY>",
"client_email": "<CLIENT_EMAIL>",
"client_id": "<CLIENT_ID>",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://accounts.google.com/o/oauth2/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/<CLIENT_EMAIL>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}' \
"https://app.datadoghq.com/api/v1/integration/gcp?api_key=${api_key}&application_key=${app_key}"
# Update a GCP Service Account's automute option in Datadog
# project_id and client_email are required
curl -X PUT -H "Content-type: application/json" \
-d '{
"project_id": "<GCP_PROJECT_ID>",
"client_email": "<CLIENT_EMAIL>",
"automute": <AUTOMUTE> # true or false
}' \
"https://app.datadoghq.com/api/v1/integration/gcp?api_key=${api_key}&application_key=${app_key}"
# Update a GCP Service Account's host filters in Datadog
# project_id and client_email are required
curl -X PUT -H "Content-type: application/json" \
-d '{
"project_id": "<GCP_PROJECT_ID>",
"client_email": "<CLIENT_EMAIL>",
"host_filters": "<KEY_1>:<VALUE_1>,<KEY_2>:<VALUE_2>"
}' \
"https://app.datadoghq.com/api/v1/integration/gcp?api_key=${api_key}&application_key=${app_key}"
# Delete a GCP Service Account in Datadog
# project_id and client_email are required
curl -X DELETE -H "Content-type: application/json" \
-d '{
"project_id": "<GCP_PROJECT_ID>",
"client_email": "<CLIENT_EMAIL>"
}' \
"https://app.datadoghq.com/api/v1/integration/gcp?api_key=${api_key}&application_key=${app_key}"# 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 OKConfigure your Datadog-PagerDuty integration directly through the Datadog API.
Read more about Datadog-PagerDuty integration.
Note:
POST method updates your integration configuration by adding your new configuration to the existing one in your Datadog organization.PUT method updates your integration configuration by replacing your current configuration with the new one sent to your Datadog organization.PUT) a new PagerDuty configuration.services :
Array of PagerDuty service objects. Learn how to configure you Datadog service with PagerDuty documentation. A PagerDuty service object is composed by:
service_name [required]:
Your Service name in PagerDuty.
service_key [required]:
Your Service name associated service key in Pagerduty.
subdomain :
Your PagerDuty account’s personalized subdomain name.
schedules :
Array of your schedule URLs, e.g:
["https://my-pd.pagerduty.com/schedules#PCPYT4M", "https://my-pd.pagerduty.com/schedules#PKTPB7P"]
api_token :
Your PagerDuty API token.
https://api.datadoghq.com/api/v1/integration/pagerduty
# 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 # Create a new configuration.
# WARNING: This will replace your current configuration.
curl -v -X PUT -H "Content-type: application/json" \
-d '{
"services": [
{
"service_name": "test_00",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
},
{
"service_name": "test_01",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
}
],
"subdomain": "<PAGERDUTY_SUB_DOMAIN>",
"schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
"api_token": "<PAGERDUTY_TOKEN>"
}' \
"https://api.datadoghq.com/api/v1/integration/pagerduty?api_key=${api_key}&application_key=${app_key}"
# Update an existing configration.
# In this example, we are overriding `subdomain`, `api_token` and `schedules` values
# with new values.
curl -v -X PUT -H "Content-type: application/json" \
-d '{
"subdomain": "<PAGERDUTY_SUB_DOMAIN>",
"schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
"api_token": "<PAGERDUTY_TOKEN>"
}' \
"https://api.datadoghq.com/api/v1/integration/pagerduty?api_key=${api_key}&application_key=${app_key}"
# Add new services and schedules to the existing configuration.
curl -v -X POST -H "Content-type: application/json" \
-d '{
"services": [
{
"service_name": "test_00",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
},
{
"service_name": "test_01",
"service_key": "<PAGERDUTY_SERVICE_KEY>"
}
],
"schedules": ["<SCHEDULE_1>", "<SCHEDULE_2>"],
}' \
"https://api.datadoghq.com/api/v1/integration/pagerduty?api_key=${api_key}&application_key=${app_key}"
# Get the integration configuration.
curl -v -X GET \
"https://api.datadoghq.com/api/v1/integration/pagerduty?api_key=${api_key}&application_key=${app_key}"
# Delete the integration configuration.
curl -v -X DELETE \
"https://api.datadoghq.com/api/v1/integration/pagerduty?api_key=${api_key}&application_key=${app_key}"
# 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 OKConfigure your Datadog-Slack integration directly through Datadog API.
Read more about Datadog-Slack integration.
Note:
POST method updates your integration configuration by adding your new configuration to the existing one in your Datadog organization.PUT method updates your integration configuration by replacing your current configuration with the new one sent to your Datadog organization.service_hooks [required]:
Array of service hook objects (the service hook is generated for your slack account in your Slack account administration page). A service hook object is composed by:
account [required]:
Your Slack account name.
url [required]:
Your Slack Service Hook URL.
Note: service_hooks are not required in the payload when adding (POST) or updating (PUT) an existing Slack configuration.
channels [required]:
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.
https://api.datadoghq.com/api/v1/integration/slack
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example #!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account
api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>
curl -v -X POST -H "Content-type: application/json" \
-d '{
"service_hooks": [
{
"account": "<SLACK_ACCOUNT_1>",
"url": "https://hooks.slack.com/services/1/1"
},
{
"account": "<SLACK_ACCOUNT_2>",
"url": "https://hooks.slack.com/services/2/2"
}
],
"channels": [
{
"channel_name": "<CHANNEL_NAME_1>",
"transfer_all_user_comments": "false",
"account": "<SLACK_ACCOUNT_1>"
},
{
"channel_name": "<CHANNEL_NAME_2>",
"transfer_all_user_comments": "false",
"account": "<SLACK_ACCOUNT_2>"
}
]
}' \
"https://api.datadoghq.com/api/v1/integration/slack?api_key=${api_key}&application_key=${app_key}"
curl -v -X PUT -H "Content-type: application/json" \
-d '{
"service_hooks": [
{
"account": "<SLACK_ACCOUNT_1>",
"url": "https://hooks.slack.com/services/1/1"
},
{
"account": "<SLACK_ACCOUNT_2>",
"url": "https://hooks.slack.com/services/2/2"
}
],
"channels": [
{
"channel_name": "<CHANNEL_NAME_1>",
"transfer_all_user_comments": "false",
"account": "<SLACK_ACCOUNT_1>"
},
{
"channel_name": "<CHANNEL_NAME_2>",
"transfer_all_user_comments": "false",
"account": "<SLACK_ACCOUNT_2>"
}
]
}' \
"https://api.datadoghq.com/api/v1/integration/slack?api_key=${api_key}&application_key=${app_key}"
# Adding channels to existing configurations
curl -X POST -H "Content-type: application/json" \
-d '{
"channels": [
{
"channel_name": "<CHANNEL_NAME_3>",
"transfer_all_user_comments": "false",
"account": "<SLACK_ACCOUNT_1>"
},
{
"channel_name": "<CHANNEL_NAME_4>",
"transfer_all_user_comments": "false",
"account": "<SLACK_ACCOUNT_2>"
}
]
}' \
"https://app.datadoghq.com/api/v1/integration/slack?api_key=${api_key}&application_key=${app_key}"
curl -v "https://api.datadoghq.com/api/v1/integration/slack?api_key=${api_key}&application_key=${app_key}"
curl -v -X DELETE "https://api.datadoghq.com/api/v1/integration/slack?api_key=${api_key}&application_key=${app_key}"
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example OK
Configure your Datadog-Webhooks integration directly through Datadog API.
Read more about Datadog-Webhooks integration.
Note:
POST method updates your integration configuration by adding your new configuration to the existing one in your Datadog organization.PUT method updates your integration configuration by replacing your current configuration with the new one sent to your Datadog organization.hooks [required]:
Array of Webhook objects. A Webhook object is composed by:
name [required]:url [required]:use_custom_payload [optional, default=False]:
If true, allow you to specify a custom payload for your Webhook.
custom_payload [optional, default=None]:
If use_custom_payload is true, specify your own payload to add your own custom fields to the request using those variables.
encode_as_form [optional, default=False]:
If use_custom_payload is true, set this to true to have your payload to be URL-encoded.
headers [optional, default=None]:
Headers attached to your Webhook.
https://api.datadoghq.com/api/v1/integration/webhooks
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example #!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account
api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>
curl -v -X POST -H "Content-type: application/json" \
-d '{
"hooks": [
{
"name": "<WEBHOOK_NAME>",
"url": "<WEBHOOK_URL>",
"use_custom_payload": "false",
"custom_payload": "",
"encode_as_form": "false",
"headers": ""
}
]
}' \
"https://api.datadoghq.com/api/v1/integration/webhooks?api_key=${api_key}&application_key=${app_key}"
curl -v -X PUT -H "Content-type: application/json" \
-d '{
"hooks": [
{
"name": "<WEBHOOK_NAME>",
"url": "<WEBHOOK_URL>"
}
]
}' \
"https://api.datadoghq.com/api/v1/integration/webhooks?api_key=${api_key}&application_key=${app_key}"
curl -v "https://api.datadoghq.com/api/v1/integration/webhooks?api_key=${api_key}&application_key=${app_key}"
curl -v -X DELETE "https://api.datadoghq.com/api/v1/integration/webhooks?api_key=${api_key}&application_key=${app_key}"
# 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 OKSend your logs to your Datadog platform over HTTP. Limits per HTTP request are:
Note: If you are in the Datadog EU site (app.datadoghq.eu), the HTTP log endpoint is: http-intake.logs.datadoghq.eu.
| Item | Description |
|---|---|
| Protocol | http: 80 https: 443 |
| Host | For Datadog US: http-intake.logs.datadoghq.com For Datadog EU: http-intake.logs.datadoghq.eu |
| Path | /v1/input/<DATADOG_API_KEY> |
| Query parameters | Query parameters available are the reserved log attribute. ?ddtags=<TAGS>&ddsource=<SOURCE>&service=<SERVICE>&hostname=<HOSTNAME> |
| Method | POST |
| Content Type | Available content type are: text/plain, application/json, application/logplex-1 |
https://http-intake.logs.datadoghq.com/v1/input/<DATADOG_API_KEY>
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example ## Simple Raw Message
## Log attributes can be passed as query parameters
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY>?ddtags=env:prod,user:my-user \
-H "Content-Type: text/plain" \
-d 'hello world'
## Multi Raw Messages
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: text/plain" \
--data-binary @- <<BODY
hello
world
BODY
## Simple JSON Message
## Log attributes can also be passed as key:value pairs in valid JSON messages
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: application/json" \
-d '{"message":"hello world", "ddsource":"<SOURCE>", "ddtags":"env:<ENV>,user:<USER_NAME>", "hostname":"<HOSTNAME>"}'
## Multi JSON Messages
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: application/json" \
--data-binary @- <<BODY
[
{
"message": "hello"
},
{
"message": "world"
}
]
BODY
## Simple Logplex Message
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: application/logplex-1" \
-d 'hello world'
## Multi Logplex Messages
curl -X POST https://http-intake.logs.datadoghq.com/v1/input/<API_KEY> \
-H "Content-Type: application/logplex-1" \
--data-binary @- <<BODY
hello
world
BODY
# 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 {}List endpoint returns logs that match a log search query. Results are paginated.
query [required]:time.from [required]:time.to [required]:time.timezone [optional, default=None]:
Can be specified both as an offset (e.g. “UTC+03:00”) or a regional zone (e.g. “Europe/Paris”)time.offset [optional, default=None]:
Equivalent to time.timezone. But value in seconds.
If both timezone and offset are specified, timezone is ignored.startAt [optional, default=None]:id attribute. This parameter is used for the pagination feature.
Note: this parameter is ignored if the corresponding log is out of the scope of the specified time window.sort [optional, default=desc]:asc or time-descending descresults.limit [optional, default=10]:index [optional, default=main]:Retrieve a log list longer than the 1000 logs limit with the Log List API Pagination feature:
startAt parameter.nextLogID of N-1th request result as the startAt parameter value.For better control over pagination results, you should use an absolute time parameter - don’t use thenow keyword.
If you are thinking about archiving logs for your organization, consider using Datadog archive capabilities instead of the log list API. See Datadog Logs Archive documentation.
POST api/v1/logs-queries/list
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example #!/bin/sh
# Make sure you replace the <DD_API_KEY> and <DD_APP_KEY> key below
# with the ones for your account
api_key=<DD_API_KEY>
app_key=<DD_APP_KEY>
curl -X POST \
'https://api.datadoghq.com/api/v1/logs-queries/list?api_key=${api_key}&application_key=${app_key}' \
-H 'content-type: application/json' \
-d '{"query": "service:nginx -@http.method:POST","time": {"from": "2019-03-20T09:00Z", "to": "2019-03-20T10:00Z"}, "sort": "desc", "limit": 50}'
# 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"
}The metrics end-point allows you to:
As occurs within the Datadog UI, 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.
Thus, if you are querying for larger timeframes of data, the points returned is more aggregated. The max granularity within Datadog is one point per second, so if you had submitted points at that interval and requested a very small interval from the query API (in this case, probably less than 100 seconds), you could end up getting all of those points back. Otherwise, Datadog algorithm tries to return about 150 points per any given time window, so you’ll see coarser and coarser granularity as the amount of time requested increases. We do this time aggregation via averages.
We store metric points at the 1 second resolution, but we’d prefer if you only submitted points every 15 seconds. Any metrics with fractions of a second timestamps gets rounded to the nearest second, and if any points have the same timestamp, the latest point overwrites the previous ones.
We have a soft limit of 100 timeseries per host, where a timeseries is defined as a unique combination of metric name and tag.
Get the list of actively reporting metrics from a given time until now. This endpoint is not available in the Python and Ruby libraries.
from [required]:GET https://api.datadoghq.com/api/v1/metrics
from datadog import initialize, api
import time
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Taking the last 24hours
from_time = int(time.time()) - 60 * 60 * 24 * 1
result = api.Metric.list(from_time)
print(result)
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
from_time=$(date -v -1d +%s)
curl -G \
"https://api.datadoghq.com/api/v1/metrics" \
-d "api_key=${api_key}" \
-d "application_key=${app_key}" \
-d "from=${from_time}"
{
"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
}The metrics end-point allows you to post time-series data that can be graphed on Datadog’s dashboards.
series [required]:
Pass a JSON array where each item in the array contains the following arguments:
metric [required]:type [optional, default=gauge]:gauge, rate, or countinterval [optional, default=None]:rate or count, define the corresponding interval.points [required]:[[POSIX_timestamp, numeric_value], ...]host [optional]:tags [optional, default=None]:POST https://api.datadoghq.com/api/v1/series
from datadog import initialize, api
import time
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
now = time.time()
future_10s = now + 10
# Submit a single point with a timestamp of `now`
api.Metric.send(metric='page.views', points=1000)
# Submit a point with a timestamp (must be ~current)
api.Metric.send(metric='my.pair', points=(now, 15))
# Submit multiple points.
api.Metric.send(
metric='my.series',
points=[
(now, 15),
(future_10s, 16)
]
)
# Submit a point with a host and tags.
api.Metric.send(
metric='my.series',
points=100,
host="myhost.example.com",
tags=["version:1"]
)
# Submit multiple metrics
api.Metric.send([{
'metric': 'my.series',
'points': 15
}, {
'metric': 'my1.series',
'points': 16
}])
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Submit one metric value.
dog.emit_point('some.metric.name', 50.0, :host => "my_host.example.com")
# Submit multiple metric values
points = [
[Time.now, 0],
[Time.now + 10, 10.0],
[Time.now + 20, 20.0]
]
dog.emit_points('some.metric.name', points, :tags => ["version:1"])
# Emit differents metrics in a single request to be more efficient
dog.batch_metrics do
dog.emit_point('test.api.test_metric',10)
dog.emit_point('test.api.this_other_metric', 1)
end
currenttime=$(date +%s)
curl -X POST -H "Content-type: application/json" \
-d "{ \"series\" :
[{\"metric\":\"test.metric\",
\"points\":[[$currenttime, 20]],
\"type\":\"rate\",
\"interval\": 20,
\"host\":\"test.example.com\",
\"tags\":[\"environment:test\"]}
]
}" \
'https://api.datadoghq.com/api/v1/series?api_key=<YOUR_API_KEY>'
This end point allows you to query for metrics from any time period.
Note: In Python, from is a reserved word. So instead, the Python API uses the start and end parameters in the function call.
from [required except in Python]:to [required except in Python]:start [required in Python, default=None]:end [required in Python, default=None]:query [required]:GET https://api.datadoghq.com/api/v1/query
from datadog import initialize, api
import time
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
now = int(time.time())
query = 'system.cpu.idle{*}by{host}'
print api.Metric.query(start=now - 3600, end=now, query=query)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get points from the last hour
from = Time.now - 3600
to = Time.now
query = 'system.cpu.idle{*}by{host}'
dog.get_points(query, from, to)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
to_time=$(date +%s)
from_time=$(date -v -1d +%s)
curl -G \
"https://api.datadoghq.com/api/v1/query" \
-d "api_key=${api_key}" \
-d "application_key=${app_key}" \
-d "from=${from_time}" \
-d "to=${to_time}" \
-d "query=system.cpu.idle{*}by{host}"
{
'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": ""
}The metrics metadata endpoint allows you to get metadata about a specific metric.
This end point takes no JSON arguments.
GET https://api.datadoghq.com/api/v1/metrics/<METRIC_NAME>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
metric = 'system.cpu.idle'
api.Metadata.get(metric_name=metric)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get metadata on metric
result = dog.get_metadata('system.net.bytes_sent')
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
metric_name="system.net.bytes_sent"
curl "https://api.datadoghq.com/api/v1/metrics/${metric_name}?api_key=${api_key}&application_key=${app_key}"
{
'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"
}The metrics metadata endpoint allows you to edit fields of a metric’s metadata. Find more about supported types
type [required]:description [optional, default=None]:short_name [required]:unit [optional, default=None]:per_unit [optional, default=None]:statsd_interval [optional, default=None]:PUT https://api.datadoghq.com/api/v1/metrics/<METRIC_NAME>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
metric = 'system.net.bytes_sent'
params = {
'description': 'My custom description',
'short_name': 'bytes sent',
'type': 'gauge',
'unit': 'byte',
'per_unit': 'second'
}
api.Metadata.update(metric_name=metric, **params)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
updates = {
"type" => "gauge",
"description" => "my custom description",
"short_name" => "bytes sent",
"unit" => "byte",
"per_unit" => "second"
}
# Submit updates for metric
result = dog.update_metadata('system.net.bytes_sent', updates)api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
metric_name="system.net.bytes_sent"
curl -X PUT -H "Content-type: application/json" \
-d '{
"type": "gauge",
"description": "my custom description",
"short_name": "bytes sent",
"unit": "byte",
"per_unit": "second"
}' \
"https://api.datadoghq.com/api/v1/metrics/${metric_name}?api_key=${api_key}&application_key=${app_key}"
{
'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"
}This end point allows you to search for metrics from the last 24 hours in Datadog.
q [required]:
The query string. Must be prefixed with metrics:.GET https://api.datadoghq.com/api/v1/search
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
api.Hosts.search(q="metrics:system")
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
dog.search("metrics:system")
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -G "https://api.datadoghq.com/api/v1/search" \
-d "api_key=${api_key}" \
-d "application_key=${app_key}" \
-d "q=metrics:test"
{
'results': {
'metrics': [
'test.metric.metric',
'test.tag.metric'
]
}
}
["200", {
"results" => {
"metrics" => ["test.metric"]
}
}]
{
"results": {
"metrics": [
"test.metric"
]
}
}
Monitors allow you to watch a metric or check that you care about, notifying your team when some defined threshold is exceeded.
Refer to the Creating Monitors page for more information on creating monitors.
If you manage and deploy monitors programmatically, it’s easier to define the monitor in the Datadog UI and export its valid JSON.
type [required]:| Monitor Type | type attribute value |
|---|---|
| anomaly | query alert |
| apm | query alert |
| composite | composite |
| custom | service check |
| event | event alert |
| forecast | query alert |
| host | service check |
| integration | query alert |
| live process | process alert |
| logs | log alert |
| metric | query alert |
| network | service check |
| outlier | query alert |
| process | service check |
query [required]:
The query defines when the monitor triggers. Query syntax depends on what type of monitor you are creating:
time_aggr(time_window):space_aggr:metric{tags} [by {key}] operator #
time_aggr: avg, sum, max, min, change, or pct_changetime_window: last_#m (with # being 5, 10, 15, or 30) or last_#h(with # being 1, 2, or 4), or last_1dspace_aggr: avg, sum, min, or maxtags: one or more tags (comma-separated), or *key: a ‘key’ in key:value tag syntax; defines a separate alert for each tag in the group (multi-alert)operator: <, <=, >, >=, ==, or !=#: an integer or decimal number used to set the thresholdIf you are using the _change_ or _pct_change_ time aggregator, instead use change_aggr(time_aggr(time_window), timeshift):space_aggr:metric{tags} [by {key}] operator # with:
change_aggr change, pct_changetime_aggr avg, sum, max, min Learn moretime_window last#m (1, 5, 10, 15, or 30), last#h (1, 2, or 4), or last_#d (1 or 2)timeshift #m_ago (5, 10, 15, or 30), #h_ago (1, 2, or 4), or 1d_agoUse this to create an outlier monitor using the following query: avg(last_30m):outliers(avg:system.cpu.user{role:es-events-data} by {host}, 'dbscan', 7) > 0
"check".over(tags).last(count).count_by_status()
check name of the check, e.g. datadog.agent.uptags one or more quoted tags (comma-separated), or “*“. e.g.: .over("env:prod", "role:db")count must be at >= your max threshold (defined in the options). e.g. if you want to notify on 1 critical, 3 ok and 2 warn statuses count should be 3.events('sources:nagios status:error,warning priority:normal tags: "string query"').rollup("count").last("1h")"
event, the event query string:string_query free text query to match against event title and text.sources event sources (comma-separated). Complete list of source attribute valuesstatus event statuses (comma-separated). Valid options: error, warn, and info.priority event priorities (comma-separated). Valid options: low, normal, all.host event reporting host (comma-separated).tags event tags (comma-separated).excluded_tags exluded event tags (comma-separated).rollup the stats rollup method. count is the only supported method now.last the timeframe to roll up the counts. Examples: 60s, 4h. Supported timeframes: s, m, h and d.processes(search).over(tags).rollup('count').last(timeframe) operator #
search free text search string for querying processes. Matching processes match results on the Live Processes pagetags one or more tags (comma-separated)timeframe the timeframe to roll up the counts. Examples: 60s, 4h. Supported timeframes: s, m, h and doperator <, <=, >, >=, ==, or !=# an integer or decimal number used to set the threshold12345 && 67890, where 12345 and 67890 are the IDs of non-composite monitors
name [required, default = dynamic, based on query]:
The name of the alert.
message [required, default = dynamic, based on query]:
A message to include with notifications for this monitor. Email notifications can be sent to specific users by using the same ‘@username’ notation as events.
tags [optional, default = empty list]:
A list of tags to associate with your monitor. When getting all monitor details via the API, use the monitor_tags argument to filter results by these tags. It is only available via the API and isn’t visible or editable in the Datadog UI.
options [optional, default={}]:
A dictionary of options for the monitor. There are options that are common to all types as well as options that are specific to certain monitor types.
silenced dictionary of scopes to timestamps or None. Each scope is muted until the given POSIX timestamp or forever if the value is None. Default: None
Examples:
{'*': None}role:db for a short time: {'role:db': 1412798116}notify_no_data a boolean indicating whether this monitor notifies when data stops reporting. Default: false
new_host_delay Time (in seconds) to allow a host to boot and applications to fully start before starting the evaluation of monitor results. Should be a non negative integer. Default: 300
no_data_timeframe the number of minutes before a monitor notifies when data stops reporting. Must be at least 2x the monitor timeframe for metric alerts or 2 minutes for service checks. Default: 2x timeframe for metric alerts, 2 minutes for service checks
timeout_h the number of hours of the monitor not reporting data before it automatically resolves from a triggered state. Default: None.
require_full_window a boolean indicating whether this monitor needs a full window of data before it’s evaluated. We highly recommend you set this to False for sparse metrics, otherwise some evaluations are skipped. Default: True for “on average”, “at all times” and “in total” aggregation. False otherwise.
renotify_interval the number of minutes after the last notification before a monitor re-notifies on the current status. It only re-notifies if it’s not resolved. Default: None.
escalation_message a message to include with a re-notification. Supports the ‘@username’ notification we allow elsewhere. Not applicable if renotify_interval is None. Default: None.
notify_audit a boolean indicating whether tagged users is notified on changes to this monitor. Default: False
locked a boolean indicating whether changes to to this monitor should be restricted to the creator or admins. Default: False
include_tags a boolean indicating whether notifications from this monitor automatically inserts its triggering tags into the title. Default: True Examples:
[Triggered on {host:h1}] Monitor Title[Triggered] Monitor TitleThese options only apply to anomaly monitors and are ignored for other monitor types.
threshold_windows a dictionary containing recovery_window and trigger_window.
recovery_window describes how long an anomalous metric must be normal before the alert recoverstrigger_window describes how long a metric must be anomalous before an alert triggers
Example: {'threshold_windows': {'recovery_window': 'last_15m', 'trigger_window': 'last_15m'}}
These options only apply to metric alerts.
thresholds a dictionary of thresholds by threshold type. There are two threshold types for metric alerts: critical and warning. Critical is defined in the query, but can also be specified in this option. Warning threshold can only be specified using the thresholds option.
If you want to use recovery thresholds for your monitor, use the attributes critical_recovery and warning_recovery.
Example: `{'critical': 90, 'warning': 80, 'critical_recovery': 70, 'warning_recovery': 50}`
evaluation_delay Time (in seconds) to delay evaluation, as a non-negative integer. For example, if the value is set to 300 (5min), the timeframe is set to last_5m and the time is 7:00, the monitor evaluates data from 6:50 to 6:55. This is useful for AWS CloudWatch and other backfilled metrics to ensure the monitor always has data during evaluation.
These options only apply to service checks and are ignored for other monitor types.
thresholds a dictionary of thresholds by status. Because service checks can have multiple thresholds, we don’t define them directly in the query.
Example: `{'ok': 1, 'critical': 1, 'warning': 1}`
POST https://api.datadoghq.com/api/v1/monitor
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Create a new 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=options
)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Create a new monitor
options = {
'notify_no_data' => true,
'no_data_timeframe' => 20
}
tags = ['app:webserver', 'frontend']
dog.monitor("metric alert", "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100", :name => "Bytes received on host0", :message => "We may need to add web hosts if this is consistently high.", :tags => tags, :options => options)#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -X POST -H "Content-type: application/json" \
-d '{
"type": "metric alert",
"query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
"name": "Bytes received on host0",
"message": "We may need to add web hosts if this is consistently high.",
"tags": ["app:webserver", "frontend"],
"options": {
"notify_no_data": true,
"no_data_timeframe": 20
}
}' \
"https://api.datadoghq.com/api/v1/monitor?api_key=${api_key}&application_key=${app_key}"{'creator': {'email': 'matt@example.com',
'handle': 'matt@example.com',
'id': 1896,
'name': u'Matt'},
'id': 2081,
'message': 'We may need to add web hosts if this is consistently high.',
'name': 'Bytes received on host0',
'tags': ['app:webserver', 'frontend'],
'options': {'no_data_timeframe': 20,
'notify_audit': False,
'notify_no_data': True,
'silenced': {}},
'org_id': 2,
'overall_state': 'No Data',
'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
'type': 'metric alert',
'multi': False,
'created': '2015-12-18T16:34:14.014039+00:00',
'modified': '2015-12-18T16:34:14.014039+00:00'
}
["200", {
"name" => "Bytes received on host0",
"org_id" => 1499,
"tags" => ["app:webserver", "frontend"],
"options" => {
"notify_no_data" => true,
"no_data_timeframe" => 20,
"notify_audit" => false,
"silenced" => {}
},
"state" => {},
"query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
"message" => "We may need to add web hosts if this is consistently high.",
"type" => "metric alert",
"id" => 92089,
"multi" => false,
"created" => "2015-12-18T16:34:14.014039+00:00",
"modified" => "2015-12-18T16:34:14.014039+00:00"
}]{
"id": 92090,
"message": "We may need to add web hosts if this is consistently high.",
"name": "Bytes received on host0",
"tags": ["app:webserver", "frontend"],
"options": {
"no_data_timeframe": 20,
"notify_audit": false,
"notify_no_data": true,
"silenced": {}
},
"org_id": 1499,
"query": "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
"state": {},
"type": "metric alert",
"multi": false,
"created": "2015-12-18T16:34:14.014039+00:00",
"modified": "2015-12-18T16:34:14.014039+00:00"
}
group_states [optional, default=None]:GET https://api.datadoghq.com/api/v1/monitor/<MONITOR_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Get a monitor's details
api.Monitor.get(2081, group_states='all')
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get a monitors's details
dog.get_monitor(91879, :group_states => 'all')#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
monitor_id=<YOUR_MONITOR_ID>
# Show a monitor
curl -G "https://api.datadoghq.com/api/v1/monitor/${monitor_id}" \
-d "api_key=${api_key}" \
-d "application_key=${app_key}" \
-d "group_states=all"
{
'id': 2081,
'message': 'We may need to add web hosts if this is consistently high.',
'name': 'Bytes received on host0',
'options': {
'no_data_timeframe': 20,
'notify_audit': False,
'notify_no_data': True,
'silenced': {}
},
'org_id': 2,
'overall_state': 'No Data',
'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
'type': 'metric alert',
'multi': False,
'created': '2015-12-18T16:34:14.014039+00:00',
'modified': '2015-12-18T16:34:14.014039+00:00',
"state": {
"groups": {
"host:host0": {
"last_nodata_ts": null,
"last_notified_ts": 1481909160,
"last_resolved_ts": 1481908200,
"last_triggered_ts": 1481909160,
"name": "host:host0",
"status": "Alert",
"triggering_value": {
"from_ts": 1481909037,
"to_ts": 1481909097,
"value": 1000
}
}
}
}
}
["200", {
"name" => "Bytes received on host0",
"org_id" => 1499,
"options" => {
"no_data_timeframe" => 20,
"notify_no_data" => false,
"notify_audit" => false,
"silenced" => {}
},
"query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
"message" => "We may need to add web hosts if this is consistently high.",
"type" => "metric alert",
"id" => 91879,
"multi" => false,
"created" => "2015-12-18T16:34:14.014039+00:00",
"modified" => "2015-12-18T16:34:14.014039+00:00",
"state" => {
"groups" => {
"host:host0" => {
"last_nodata_ts" => null,
"last_notified_ts" => 1481909160,
"last_resolved_ts" => 1481908200,
"last_triggered_ts" => 1481909160,
"name" => "host:host0",
"status" => "Alert",
"triggering_value" => {
"from_ts" => 1481909037,
"to_ts" => 1481909097,
"value" => 1000
}
}
}
}
}]
{
"id": 91879,
"message": "We may need to add web hosts if this is consistently high.",
"name": "Bytes received on host0",
"options": {
"no_data_timeframe": 20,
"notify_audit": false,
"notify_no_data": false,
"silenced": {}
},
"org_id": 1499,
"query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
"type": "metric alert",
"multi": false,
"created": "2015-12-18T16:34:14.014039+00:00",
"modified": "2015-12-18T16:34:14.014039+00:00",
"state": {
"groups": {
"host:host0": {
"last_nodata_ts": null,
"last_notified_ts": 1481909160,
"last_resolved_ts": 1481908200,
"last_triggered_ts": 1481909160,
"name": "host:host0",
"status": "Alert",
"triggering_value": {
"from_ts": 1481909037,
"to_ts": 1481909097,
"value": 1000
}
}
}
}
}
query [required]:name [required]:message [optional, default=dynamic, based on query]:
A message to include with notifications for this monitor. Email notifications can be sent to specific users by using the same ‘@username’ notation as events.options [optional, default={}]:tags [optional, default=None]:PUT https://api.datadoghq.com/api/v1/monitor/<MONITOR_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Edit an existing monitor
api.Monitor.update(
2081,
query="avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100",
name="Bytes received on host0",
message="We may need to add web hosts if this is consistently high."
)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Edit an existing monitor
dog.update_monitor(91879, "avg(last_5m):sum:system.net.bytes_rcvd{host:host0} > 100", :message => "Bytes received on host0", :name => "We may need to add web hosts if this is consistently high.")#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
monitor_id=<YOUR_MONITOR_ID>
# Edit a monitor
curl -X PUT -H "Content-type: application/json" \
-d '{
"query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
"name": "Bytes received on host0",
"message": "We may need to add web hosts if this is consistently high."
}' \
"https://api.datadoghq.com/api/v1/monitor/${monitor_id}?api_key=${api_key}&application_key=${app_key}"
{
'id': 2081,
'message': 'We may need to add web hosts if this is consistently high.',
'name': 'Bytes received on host0',
'options': {'notify_audit': False, 'notify_no_data': False, 'silenced': {}},
'org_id': 2,
'overall_state': 'No Data',
'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
'type': 'metric alert',
'multi': False,
'created': '2015-12-18T16:34:14.014039+00:00',
'modified': '2015-12-18T18:39:24.391207+00:00'
}
[
"200", {
"name" => "We may need to add web hosts if this is consistently high.",
"org_id" => 1499,
"options" => {
"notify_no_data" => false, "notify_audit" => false, "silenced" => {}
},
"state" => {},
"query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
"message" => "Bytes received on host0",
"type" => "metric alert",
"id" => 91879,
"multi" => false,
"created" => "2015-12-18T16:34:14.014039+00:00",
"modified" => "2015-12-18T18:39:24.391207+00:00"
}
]{ "id": 91879,
"message": "We may need to add web hosts if this is consistently high.",
"name": "Bytes received on host0",
"options": {
"notify_audit": false,
"notify_no_data": false,
"silenced": {}
},
"org_id": 1499,
"query": "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
"state": {},
"type": "metric alert",
"multi": false,
"created": "2015-12-18T16:34:14.014039+00:00",
"modified": "2015-12-18T18:39:24.391207+00:00"}This end point takes no JSON arguments.
DELETE https://api.datadoghq.com/api/v1/monitor/<MONITOR_ID>
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Delete a monitor
api.Monitor.delete(2081)
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Delete a monitor
dog.delete_monitor(62625)#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
monitor_id=<YOUR_MONITOR_ID>
# Delete a monitor
curl -X DELETE "https://api.datadoghq.com/api/v1/monitor/${monitor_id}?api_key=${api_key}&application_key=${app_key}"
{
'deleted_monitor_id': 2081
}
["200", {
"deleted_monitor_id" => 62625
}]{
"deleted_monitor_id": 59409
}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’name [optional, default=None]:
A string to filter monitors by nametags [optional, default=None]:host:host0. For more information, see the tags parameter for the appropriate query argument in the Create a monitor section above.monitor_tags [optional, default=None]:service:my-app)with_downtimes [optional, default = true]:true, then the returned data includes all current downtimes for each monitor.GET https://api.datadoghq.com/api/v1/monitor
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Get all monitor details
print api.Monitor.get_all()
require 'rubygems'
require 'dogapi'
api_key = '<YOUR_API_KEY>'
app_key = '<YOUR_APP_KEY>'
dog = Dogapi::Client.new(api_key, app_key)
# Get all monitor details
dog.get_all_monitors()#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -G "https://api.datadoghq.com/api/v1/monitor" \
-d "api_key=${api_key}" \
-d "application_key=${app_key}"
[
{'creator': {
'email': 'matt@example.com',
'handle': 'matt@example.com',
'id': 1896,
'name': u'Matt'
},
'id': 2085,
'message': u'',
'name': '**system.net.bytes_rcvd** over **host:host0** was **> 100** on average during the **last 1h**.',
'options': {'notify_audit': False, 'notify_no_data': False, 'silenced': {}},
'org_id': 2,
'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
'type': 'metric alert',
'multi': False,
'created': '2015-12-18T16:34:14.014039+00:00',
'modified': '2015-12-18T18:39:24.391207+00:00'},
{'creator': {'email': 'matt@example.com',
'handle': 'matt@example.com',
'id': 1896,
'name': u'Matt'},
'id': 2083,
'message': 'We may need to add web hosts if this is consistently high.',
'name': 'Bytes received on host0',
'options': {'no_data_timeframe': 20,
'notify_audit': False,
'notify_no_data': True,
'silenced': {}},
'org_id': 2,
'overall_state': 'No Data',
'query': 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100',
'type': 'metric alert',
'multi': False,
'created': '2015-12-18T16:34:14.014039+00:00',
'modified': '2015-12-18T18:39:24.391207+00:00'
}
]
[
"200", [{
"name" => "Bytes received on host0",
"org_id" => 1499,
"options" => {
"notify_no_data" => false, "notify_audit" => false, "silenced" => {}
},
"query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
"message" => "We may need to add web hosts if this is consistently high.",
"type" => "metric alert",
"multi" => false,
"id" => 91879,
"created" => "2015-12-18T16:34:14.014039+00:00",
"modified" => "2015-12-18T16:34:14.014039+00:00"
}, {
"name" =>
"**system.net.bytes_rcvd** over **host:host0** was **> 100** on average during the **last 1h**.",
"org_id" => 1499,
"options" => {
"notify_audit" => true,
"timeout_h" => nil,
"silenced" => {},
"no_data_timeframe" => false,
"notify_no_data" => false,
"renotify_interval" => nil,
"escalation_message" => ""
},
"query" => "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100",
"message" => "",
"type" => "metric alert",
"multi" => false,
"id" => 91875,
"created" => "2015-12-18T16:34:14.014039+00:00",
"modified" => "2015-12-18T16:34:14.014039+00:00"
}]
][
{
"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",
"type": "metric alert",
"multi": false,
"created": "2015-12-18T16:34:14.014039+00:00",
"modified": "2015-12-18T16:34:14.014039+00:00"
},
{
"id": 91875,
"message": "",
"name": "**system.net.bytes_rcvd** over **host:host0** was **> 100** on average during the **last 1h**.",
"options": {
"escalation_message": "",
"no_data_timeframe": false,
"notify_audit": true,
"notify_no_data": false,
"renotify_interval": null,
"silenced": {},
"timeout_h": null
},
"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"
}
]resolve [required]:
Array of group(s) to resolve for a given monitor_id, e.g.:
{"monitor_id": "group_to_resolve"}
It supports multiple groups per monitor, e.g.:
resolve: [{"monitor_id": "group_1"}, {"monitor_id": "group_2"}]
It can also resolve all triggered groups with the pseudo-group ALL_GROUPS:
resolve: [{"monitor_id": "ALL_GROUPS"}]
POST https://api.datadoghq.com/monitor/bulk_resolve
# This is not yet supported by the Python Client for Datadog API
# Consult the curl example
# This is not yet supported by the Ruby Client for Datadog API
# Consult the curl example
#!/bin/sh
# Replace the API and APP keys below
# with the ones for your account
api_key=<YOUR_API_KEY>
app_key=<YOUR_APP_KEY>
curl -X POST -H "Content-type: application/json" \
-d '{
"resolve": [
{"<YOUR_MONITOR_ID>": "<YOUR_FIRST_GROUP>"},
{"<YOUR_MONITOR_ID>": "<YOUR_SECOND_GROUP>"}
]
}' \
"https://app.datadoghq.com/monitor/bulk_resolve?api_key=${api_key}&application_key=${app_key}"# 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
}
}
}
]Muting prevents all monitors from notifying through email and posts to the event stream. State changes are only visible by checking the alert page.
This end point takes no JSON arguments.
POST https://api.datadoghq.com/api/v1/monitor/mute_all
from datadog import initialize, api
options = {
'api_key': '<YOUR_API_KEY>',
'app_key': '<YOUR_APP_KEY>'
}
initialize(**options)
# Mute all monitors
api.Monitor.mute_all()
require